Si vous proposez une connexion avec des comptes Google, vous pouvez utiliser le client de connexion One Tap 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'interface utilisateur de One Tap, les utilisateurs sont invités à créer un compte avec votre application à l'aide de l'un des comptes Google sur leur appareil. Si l'utilisateur choisit de continuer, vous recevez un jeton d'ID contenant des informations de profil de base (son nom, sa photo de profil et son adresse e-mail validée) que vous pouvez utiliser pour créer le compte.
La mise en œuvre de la création d'un compte One Tap se fait en deux étapes:
- Intégrer le client One Tap à votre application, comme décrit sur cette page. Cela revient principalement à utiliser la connexion avec One Tap, à quelques différences près au niveau de la configuration.
- Ajout au backend de 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.
Où dois-je m'inscrire avec One Tap ?
L'option d'inscription avec One Tap est la plus efficace dans un contexte où la connexion permet d'activer 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 de console d'API Google et votre projet Android comme décrit dans la section Premiers pas avec la connexion avec One Tap.
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 en un geste n'est possible qu'avec l'authentification par jeton.)
Activez les requêtes de jetons d'ID Google à l'aide de
setGoogleIdTokenRequestOptions()et des paramètres suivants:- 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 de sorte qu'il affiche tous les comptes Google présents sur l'appareil, c'est-à-dire de ne pas filtrer par comptes autorisés.
- Vous pouvez également demander le numéro de téléphone validé associé au 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. Suivez l'annulation de l'UI avec One Tap
Vous devez savoir si l'utilisateur a déjà refusé l'inscription avec One Tap en fermant l'invite ou en appuyant à l'extérieur de celle-ci. Il peut s'agir d'une simple propriété booléenne de votre activité. (Consultez la section Arrêter d'afficher l'interface utilisateur de One Tap ci-dessous.)
3. Afficher l'interface utilisateur 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 au Task qu'il renvoie. Les applications effectuent généralement cette étape lorsqu'une requête de connexion One Tap 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 réussite si l'utilisateur dispose d'un ou de plusieurs comptes Google configurés sur l'appareil. Dans l'écouteur de réussite, récupérez l'intent en attente à partir du résultat Task et transmettez-le à startIntentSenderForResult() pour démarrer l'interface utilisateur One Tap.
Si l'utilisateur n'a pas de compte Google sur l'appareil, le client One Tap appelle l'écouteur d'échecs. Dans ce cas, aucune action n'est requise. Vous pouvez simplement continuer à présenter l'expérience de l'application déconnectée, et l'utilisateur peut s'inscrire avec votre processus habituel de création de compte.
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 d'inscription avec One Tap est transmise à votre application via la méthode onActivityResult() de votre activité. Si l'utilisateur a choisi de créer un compte, le résultat sera un jeton d'ID Google. Si l'utilisateur a refusé de s'inscrire, en fermant l'interface utilisateur 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 ces 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'ID pour lui 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 (consultez S'authentifier avec un backend à l'aide de jetons d'ID) et connectez l'utilisateur.
Les identifiants contiennent également toutes les informations supplémentaires que vous avez demandées, telles 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) {
// ...
}
}
}
// ...
}
Ne plus afficher l'interface utilisateur de One Tap
Si l'utilisateur a refusé de se connecter, l'appel de getSignInCredentialFromIntent() génère une exception ApiException avec un code d'état CommonStatusCodes.CANCELED.
Dans ce cas, vous devez cesser temporairement d'afficher l'interface utilisateur de connexion One Tap afin de ne pas gêner vos utilisateurs avec des invites répétées. Pour ce faire, l'exemple suivant définit une propriété sur l'activité, qu'elle utilise pour déterminer s'il faut proposer à l'utilisateur la connexion avec One Tap. Toutefois, vous pouvez également enregistrer une valeur dans SharedPreferences ou utiliser une autre méthode.
Il est important de limiter le débit des invites de connexion One Tap. Si vous ne le faites pas et que l'utilisateur annule plusieurs invites d'affilée, le client One Tap n'affichera pas d'invite pendant les prochaines 24 heures.
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 One Tap, vous recevez un jeton d'ID Google qui contient des informations de profil de base: adresse e-mail, nom complet et URL de la photo de profil de l'utilisateur. Pour de nombreuses applications, ces informations vous permettent d'authentifier l'utilisateur sur le backend et de créer un compte.
Si vous avez besoin d'informations supplémentaires pour terminer la création du compte (par exemple, la date de naissance de l'utilisateur), présentez-lui une procédure d'inscription dans laquelle vous demandez ces informations supplémentaires. Envoyez-les ensuite à votre backend pour terminer la création du compte.