Si vous acceptez la connexion avec des comptes Google, vous pouvez également utiliser le client de connexion en un seul geste pour offrir à vos utilisateurs une expérience de création de compte fluide qui ne les éloigne jamais du contexte de votre application.
Lorsque vous affichez l'UI One Tap, les utilisateurs sont invités à créer un compte dans votre application à l'aide de l'un des comptes Google de leur appareil. Si l'utilisateur choisit de continuer, vous recevez un jeton d'ID contenant des informations de base sur le profil (nom, photo de profil et adresse e-mail validée), que vous pouvez utiliser pour créer le nouveau compte.
La création de compte One Tap se compose de deux parties:
- Intégrer le client One Tap à votre application, comme décrit sur cette page. Cette procédure est presque identique à celle de la connexion en un seul geste, mais avec quelques différences de configuration.
- Ajoutez à votre backend la possibilité de créer des comptes utilisateur à partir de jetons d'ID Google, comme décrit dans la section Utiliser des jetons d'ID sur le backend.
Dans quels cas dois-je utiliser l'inscription avec One Tap ?
Le meilleur endroit pour proposer l'inscription avec One Tap aux utilisateurs est dans un contexte où la connexion permet d'accéder à de nouvelles fonctionnalités. Commencez par essayer de connecter l'utilisateur avec des identifiants enregistrés. Si aucun identifiant enregistré n'est trouvé, proposez de créer un compte pour l'utilisateur.
Avant de commencer
Configurez votre projet dans la console Google APIs et votre projet Android comme décrit dans la section Premiers pas avec la fonctionnalité de connexion en un seul geste.
1. Configurer le client One Tap
Pour configurer le client One Tap pour la création de compte, procédez comme suit:
- N'activez pas les demandes d'identifiants de mot de passe. (L'inscription avec One Tap n'est possible qu'avec une authentification basée sur des jetons.)
Activez les requêtes de jetons d'ID Google à l'aide de
setGoogleIdTokenRequestOptions()et de ces paramètres:- Définissez l'ID client du serveur sur l'ID que vous avez créé dans la console des API Google. Notez qu'il s'agit de l'ID client de votre serveur, et non de votre ID client Android.
- Configurez le client pour qu'il affiche tous les comptes Google sur l'appareil, c'est-à-dire qu'il ne filtre pas par comptes autorisés.
- Vous pouvez également demander le numéro de téléphone validé du compte.
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. Suivre la résiliation de l'UI One Tap
Vous devez vérifier si l'utilisateur a déjà refusé d'utiliser l'inscription en un seul geste en fermant la requête ou en appuyant en dehors de celle-ci. Il peut s'agir d'une propriété booléenne de votre activité. (voir Arrêter l'affichage de l'interface utilisateur One Tap ci-dessous) ;
3. Afficher l'UI d'inscription avec One Tap
Si l'utilisateur n'a pas refusé d'utiliser One Tap pour créer un compte, appelez la méthode beginSignIn() de l'objet client et associez des écouteurs à l'Task qu'il renvoie. Les applications effectuent généralement cette étape lorsqu'une requête de connexion en un seul geste ne trouve aucun identifiant enregistré, c'est-à-dire dans l'écouteur d'échec de la requête de connexion.
Le client One Tap appelle l'écouteur de succès si l'utilisateur a configuré un ou plusieurs comptes Google sur l'appareil. Dans l'écouteur de succès, récupérez l'intent en attente à partir du résultat Task et transmettez-le à startIntentSenderForResult() pour démarrer l'UI One Tap.
Si l'utilisateur ne dispose d'aucun compte Google sur l'appareil, le client One Tap appelle l'écouteur d'échec. Dans ce cas, aucune action n'est requise: vous pouvez simplement continuer à présenter l'expérience de l'application lorsque l'utilisateur n'est pas connecté, et l'utilisateur peut s'inscrire avec votre parcours de création de compte normal.
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. Gérer la réponse de l'utilisateur
La réponse de l'utilisateur à l'invite de connexion en un seul geste sera transmise à votre application à l'aide de la méthode onActivityResult() de votre activité. Si l'utilisateur a choisi de créer un compte, un jeton d'ID Google est généré. Si l'utilisateur a refusé de s'inscrire, en fermant l'UI One Tap ou en appuyant en dehors de celle-ci, le résultat est renvoyé avec le code RESULT_CANCELED. Votre application doit gérer les deux possibilités.
Créer un compte avec un jeton d'ID Google
Si l'utilisateur a choisi de s'inscrire avec un compte Google, vous pouvez obtenir un jeton d'identifiant pour l'utilisateur en transmettant les données d'intent de onActivityResult() à la méthode getSignInCredentialFromIntent() du client One Tap. Les identifiants auront une propriété googleIdToken non nulle.
Utilisez le jeton d'ID pour créer un compte sur votre backend (voir la section S'authentifier auprès d'un backend à l'aide de jetons d'ID) et connecter l'utilisateur.
Les identifiants contiennent également tous les détails supplémentaires que vous avez demandés, tels que le numéro de téléphone validé du compte, le cas échéant.
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) { // ... } } } // ... }
Arrêter d'afficher l'UI One Tap
Si l'utilisateur a refusé de se connecter, l'appel à getSignInCredentialFromIntent() génère une ApiException avec un code d'état CommonStatusCodes.CANCELED.
Dans ce cas, vous devez arrêter temporairement d'afficher l'UI de connexion en un seul geste pour ne pas ennuyer vos utilisateurs avec des invites répétées. L'exemple suivant y parvient en définissant une propriété sur l'activité, qu'il utilise pour déterminer s'il doit proposer à l'utilisateur la connexion en un seul geste. Toutefois, vous pouvez également enregistrer une valeur dans SharedPreferences ou utiliser une autre méthode.
Il est important d'implémenter votre propre limitation de débit pour les invites de connexion en un seul geste. Si vous ne le faites pas et qu'un utilisateur annule plusieurs requêtes de suite, le client One Tap ne l'invitera pas pendant les 24 heures suivantes.
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})") } } } } } } // ... }
Étapes suivantes
Lorsqu'un utilisateur termine le processus d'inscription en un seul geste, vous recevez un jeton d'ID Google, qui inclut des informations de base sur le profil: l'adresse e-mail, le nom complet et l'URL de la photo de profil de l'utilisateur. Pour de nombreuses applications, ces informations suffisent pour authentifier l'utilisateur côté backend et créer un compte.
Si vous avez besoin d'informations supplémentaires pour créer un compte (par exemple, la date de naissance de l'utilisateur), présentez à l'utilisateur un flux d'informations de connexion dans lequel vous lui demandez ces informations supplémentaires. Ensuite, envoyez-les à votre backend pour créer le compte.