Si vous proposez la possibilité de vous connecter à l'aide de 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 détourne jamais du contexte de votre application.
Lorsque vous affichez l'UI One Tap, les utilisateurs sont invités à créer un compte avec votre application à l'aide de l'un des comptes Google de leur appareil. Si l'utilisateur choisit de continuer, vous recevez un jeton d'identification 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.
L'implémentation de la création d'un compte One Tap se fait en deux étapes:
- Intégrer le client One Tap dans votre application, comme décrit sur cette page. C'est presque la même chose que la connexion avec One Tap, à quelques différences près au niveau de la configuration.
- Ajouter à votre backend la possibilité de créer des comptes utilisateur à partir de jetons d'ID Google, comme expliqué dans la section Utiliser des jetons d'ID sur le backend.
Où dois-je utiliser l'inscription avec One Tap ?
L'endroit le plus efficace pour proposer l'inscription avec One Tap aux utilisateurs est lorsque 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 Android et votre projet dans la console des API Google 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'identification de mot de passe. (L'inscription en un geste n'est possible qu'avec l'authentification par jeton.)
Activez les requêtes de jeton 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 pour afficher tous les comptes Google présents sur l'appareil, c'est-à-dire ne pas filtrer 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. Suivez les annulations de l'interface utilisateur avec One Tap
Vous devez savoir si l'utilisateur a déjà refusé d'utiliser l'inscription avec One Tap en fermant l'invite ou en appuyant ailleurs. Il peut s'agir d'une 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 a configuré un ou plusieurs comptes Google sur l'appareil. Dans l'écouteur de réussite, obtenez l'intent en attente à partir du résultat Task et transmettez-le à startIntentSenderForResult() pour démarrer l'interface utilisateur One Tap.
Si l'utilisateur ne possède 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 déconnectée de l'application, et l'utilisateur peut s'inscrire en suivant votre processus normal 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, un jeton d'ID Google s'affiche. 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 pouvoir 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 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) {
// ...
}
}
}
// ...
}
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 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 agacer vos utilisateurs avec des invites répétées. L'exemple suivant permet de réaliser cette opération en définissant une propriété sur l'activité, qui permet de déterminer s'il faut proposer à l'utilisateur la connexion 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 qu'un utilisateur annule plusieurs invites d'affilée, le client One Tap ne proposera pas d'invite à l'utilisateur 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 suit la procédure d'inscription avec One Tap, vous recevez un jeton d'ID Google qui inclut 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 à l'utilisateur un flux de détails d'inscription, dans lequel vous demandez ces informations supplémentaires. Envoyez-les ensuite à votre backend pour terminer la création du compte.