Utiliser le client de connexion One Tap pour demander à l'utilisateur l'autorisation de récupérer l'un des identifiants précédemment utilisés pour se connecter à votre application. Ces Les informations d'identification peuvent être soit un compte Google, soit une combinaison nom d'utilisateur/mot de passe. enregistré avec Google via Chrome, la saisie automatique Android ou Smart Lock Mots de passe.
Une fois les identifiants récupérés, vous pouvez les utiliser pour connecter l'utilisateur à votre application.
Si l'utilisateur n'a enregistré aucun identifiant, aucune UI ne s'affiche, et vous pouvez pour bénéficier d'une expérience normale lorsque vous êtes déconnecté.
Où utiliser la connexion avec One Tap ?
Si votre application nécessite que les utilisateurs se connectent, affichez l'interface utilisateur de One Tap lors de votre connexion l'écran. Cela peut être utile même si vous disposez déjà d'un compte bouton: L'interface utilisateur de One Tap peut être configurée pour n'afficher que les identifiants qu'un utilisateur avait déjà utilisé pour se connecter, il peut s'agir d'un rappel pour les utilisateurs se connecter comme la dernière fois et éviter qu'ils ne soient accidentellement la création de nouveaux comptes avec votre application.
Si la connexion est facultative pour votre application, envisagez d'utiliser la connexion One Tap sur pour améliorer l'expérience de connexion. Par exemple, si les utilisateurs parcourir du contenu avec votre application lorsque vous êtes déconnecté, mais vous ne pouvez que publier des commentaires ou en ajouter des articles dans un panier après la connexion, il s'agit d'un contexte adapté Connexion avec One Tap.
Les applications facultatives de connexion doivent également utiliser la connexion One Tap sur leurs écrans de connexion. pour les raisons mentionnées ci-dessus.
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
- Si vous prenez en charge la connexion par mot de passe, optimisez votre application pour de saisie automatique (ou d'utiliser Smart Lock pour les mots de passe) afin que les utilisateurs puissent enregistrer mot de passe de connexion après la connexion.
1. Configurer le client de connexion One Tap
Vous pouvez configurer le client de connexion One Tap pour connecter les utilisateurs avec mots de passe, comptes Google enregistrés, etc. Il est recommandé de prendre en charge les deux activer la création de compte en un seul geste pour les nouveaux utilisateurs et la connexion automatique ou en un seul geste. pour le plus grand nombre possible d'utilisateurs connus.)
Si votre appli utilise la connexion par mot de passe, utilisez setPasswordRequestOptions() pour
activer les demandes d'identifiants de mot de passe.
Si votre application utilise Google Sign-In, utilisez setGoogleIdTokenRequestOptions() pour
activer et configurer les requêtes de jetons d'ID Google:
Définissez l'ID client du serveur sur l'ID que vous avez créé dans les API Google. console. Notez qu'il s'agit de l'ID client de votre serveur, et non votre ID client Android.
Configurez le client pour filtrer par comptes autorisés. Lorsque vous activez cette , le client One Tap n'invite les utilisateurs à se connecter à votre application qu'avec les comptes Google qu'ils ont déjà utilisés. Cela peut aider les utilisateurs à signer s'ils ne savent pas s'ils possèdent déjà un compte ou le compte Google utilisé et empêche les utilisateurs d'en créer par erreur avec votre application.
Si vous souhaitez que les utilisateurs se connectent automatiquement lorsque cela est possible, activez la fonctionnalité avec
setAutoSelectEnabled(). La connexion automatique est possible lorsque le les critères suivants sont remplis:- L'utilisateur ne dispose que d'un seul identifiant enregistré pour votre application. Autrement dit, un mot de passe ou un compte Google enregistré.
- L'utilisateur n'a pas désactivé la connexion automatique dans les paramètres de compte Google.
Bien que cette option soit facultative, nous vous recommandons vivement d'utiliser un nonce pour améliorer la sécurité de la connexion et éviter les attaques par rejeu. Utilisez setNonce pour inclure un nonce dans chaque requête. Consultez les Obtenir un nonce pour obtenir des suggestions et des informations supplémentaires sur la génération d'un nonce.
Java
public class YourActivity extends AppCompatActivity {
// ...
private SignInClient oneTapClient;
private BeginSignInRequest signInRequest;
@Override
public void onCreate(@Nullable Bundle savedInstanceState,
@Nullable PersistableBundle persistentState) {
super.onCreate(savedInstanceState, persistentState);
oneTapClient = Identity.getSignInClient(this);
signInRequest = BeginSignInRequest.builder()
.setPasswordRequestOptions(PasswordRequestOptions.builder()
.setSupported(true)
.build())
.setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
.setSupported(true)
// Your server's client ID, not your Android client ID.
.setServerClientId(getString(R.string.default_web_client_id))
// Only show accounts previously used to sign in.
.setFilterByAuthorizedAccounts(true)
.build())
// Automatically sign in when exactly one credential is retrieved.
.setAutoSelectEnabled(true)
.build();
// ...
}
// ...
}
Kotlin
class YourActivity : AppCompatActivity() {
// ...
private lateinit var oneTapClient: SignInClient
private lateinit var signInRequest: BeginSignInRequest
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
oneTapClient = Identity.getSignInClient(this)
signInRequest = BeginSignInRequest.builder()
.setPasswordRequestOptions(BeginSignInRequest.PasswordRequestOptions.builder()
.setSupported(true)
.build())
.setGoogleIdTokenRequestOptions(
BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
.setSupported(true)
// Your server's client ID, not your Android client ID.
.setServerClientId(getString(R.string.your_web_client_id))
// Only show accounts previously used to sign in.
.setFilterByAuthorizedAccounts(true)
.build())
// Automatically sign in when exactly one credential is retrieved.
.setAutoSelectEnabled(true)
.build()
// ...
}
// ...
}
2. Rechercher un utilisateur connecté
Si votre activité peut être utilisée par un utilisateur connecté ou déconnecté, vérifiez l'état de l'utilisateur avant d'afficher l'interface de connexion avec One Tap.
Vous devez également savoir si l'utilisateur a déjà refusé d'utiliser l'application Connectez-vous avec One Tap en fermant l'invite ou en appuyant à l'extérieur. Cela peut être aussi simple qu'une propriété booléenne de votre activité. (Consultez la section Arrêter d'afficher l'interface utilisateur One Tap ci-dessous.)
3. Afficher l'interface utilisateur de connexion One Tap
Si l'utilisateur n'est pas connecté et n'a pas déjà refusé d'utiliser la connexion One Tap,
appeler la méthode beginSignIn() de l'objet client et associer des écouteurs au
Task. Les applications le font généralement dans la méthode onCreate() de l'activité.
ou après les transitions d'écran en cas d'utilisation d'une architecture à activité unique.
Le client One Tap appelle l'écouteur de réussite si l'utilisateur a enregistré
les identifiants de votre application. Dans l'écouteur de réussite, récupérez l'intent en attente à partir de
le résultat Task et le transmettre à startIntentSenderForResult() pour démarrer
Interface utilisateur de connexion avec One Tap
Si l'utilisateur n'a pas enregistré d'identifiants, le client One Tap appelle la méthode d'échec. Dans ce cas, aucune action n'est requise de votre part: il vous suffit de continuer présenter l'expérience de l'application lorsque vous n'êtes pas connecté à votre compte. Toutefois, si vous acceptez One Tap vous pouvez démarrer cette procédure pour faciliter la création de votre compte. expérience. Consultez Créer des comptes d'un simple geste.
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 saved credentials found. Launch the One Tap sign-up flow, or
// do nothing and continue presenting the signed-out UI.
Log.d(TAG, e.getLocalizedMessage());
}
});
Kotlin
oneTapClient.beginSignIn(signInRequest)
.addOnSuccessListener(this) { result ->
try {
startIntentSenderForResult(
result.pendingIntent.intentSender, REQ_ONE_TAP,
null, 0, 0, 0, null)
} catch (e: IntentSender.SendIntentException) {
Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
}
}
.addOnFailureListener(this) { e ->
// No saved credentials found. Launch the One Tap sign-up flow, or
// do nothing and 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 One Tap sera transmise à votre application.
à l'aide de la méthode onActivityResult() de votre activité. Si l'utilisateur choisit
de se connecter,
le résultat sera un identifiant enregistré. Si l'utilisateur a refusé de se connecter :
en fermant l'interface utilisateur de One Tap ou en appuyant à l'extérieur, le résultat est renvoyé avec
code RESULT_CANCELED. Votre application doit gérer ces deux possibilités.
Se connecter avec les identifiants récupérés
Si l'utilisateur a choisi de partager les identifiants avec votre application, vous pouvez les récupérer en
en transmettant les données d'intent de onActivityResult() au client One Tap
getSignInCredentialFromIntent(). L'identifiant aura une valeur non nulle
Propriété googleIdToken si l'utilisateur a partagé des identifiants de compte Google avec
votre application, ou une propriété password non nulle si l'utilisateur a partagé un mot de passe enregistré.
Utilisez les identifiants pour vous authentifier auprès du backend de votre application.
- Si une paire nom d'utilisateur/mot de passe a été récupérée, utilisez-les pour vous connecter comme si l'utilisateur les avait fournis manuellement.
Si des identifiants de compte Google ont été récupérés, utilisez le jeton d'ID pour l'authentifier. avec votre backend. Si vous avez choisi d'utiliser un nonce pour éviter la rejeu les attaques vérifient la valeur de la réponse sur votre serveur backend. Voir Authentifiez-vous auprès d'un backend à l'aide de jetons d'identification.
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();
String username = credential.getId();
String password = credential.getPassword();
if (idToken != null) {
// Got an ID token from Google. Use it to authenticate
// with your backend.
Log.d(TAG, "Got ID token.");
} else if (password != null) {
// Got a saved username and password. Use them to authenticate
// with your backend.
Log.d(TAG, "Got password.");
}
} 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
val username = credential.id
val password = credential.password
when {
idToken != null -> {
// Got an ID token from Google. Use it to authenticate
// with your backend.
Log.d(TAG, "Got ID token.")
}
password != null -> {
// Got a saved username and password. Use them to authenticate
// with your backend.
Log.d(TAG, "Got password.")
}
else -> {
// Shouldn't happen.
Log.d(TAG, "No ID token or password!")
}
}
} catch (e: ApiException) {
// ...
}
}
}
}
// ...
}
Arrêter d'afficher l'interface utilisateur de 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, nous vous recommandons de désactiver temporairement l'interface utilisateur de connexion One Tap afin de
n'agace pas les utilisateurs
avec des requêtes répétées. L'exemple suivant permet
en définissant une propriété sur l'activité, qu'il utilise pour déterminer
pour proposer à l'utilisateur de se connecter avec One Tap ; mais vous pouvez aussi enregistrer une valeur
SharedPreferences ou utilisez une autre méthode.
Il est important d'implémenter votre propre limitation du débit des invites de connexion One Tap. Si ce n'est pas le cas et qu'un utilisateur annule plusieurs invites d'affilée, le client One Tap n'invitera pas l'utilisateur au cours des 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})")
}
}
}
}
}
}
// ...
}
5. Gérer la déconnexion
Lorsqu'un utilisateur se déconnecte de votre application, appelez la méthode signOut() du client One Tap.
Appeler signOut() désactive la connexion automatique jusqu'à ce que l'utilisateur se reconnecte.
Même si vous n'utilisez pas la connexion automatique, cette étape est importante, car elle garantit que lorsque les utilisateurs se déconnectent de votre application, l'état d'authentification Les API des services Play que vous utilisez sont également réinitialisées.
Étapes suivantes
Si vous avez configuré le client One Tap pour récupérer les identifiants Google, votre application peuvent désormais obtenir des jetons d'ID Google représentant l'état Comptes Google. Apprendre comment utiliser ces jetons sur le backend.
Si vous êtes compatible avec Google Sign-In, vous pouvez également utiliser le client One Tap pour ajouter des processus fluides de création de compte dans votre application.