Connectez automatiquement les utilisateurs à votre application à l'aide de l'API Credentials afin de demander et de récupérer les identifiants stockés pour vos utilisateurs.
Avant de commencer
Configurez un projet Android Studio.
Créer un objet CredentialsClient
Pour demander des identifiants stockés, vous devez créer une instance de CredentialsClient
pour accéder à l'API Credentials:
CredentialsClient mCredentialsClient;
// ...
mCredentialsApiClient = Credentials.getClient(this);
Créer un objet CredentialRequest
Un objet CredentialRequest
spécifie les systèmes de connexion à partir desquels vous souhaitez demander des identifiants. Créez un CredentialRequest
à l'aide de la méthode setPasswordLoginSupported
pour la connexion par mot de passe et de la méthode setAccountTypes()
pour les services de connexion fédérée tels que Google Sign-In.
mCredentialRequest = new CredentialRequest.Builder()
.setPasswordLoginSupported(true)
.setAccountTypes(IdentityProviders.GOOGLE, IdentityProviders.TWITTER)
.build();
Utilisez les constantes définies dans IdentityProviders
pour spécifier les fournisseurs de connexion couramment utilisés. Pour les autres fournisseurs de connexion, utilisez une chaîne qui identifie le fournisseur de manière unique. Pour stocker les identifiants, vous devez utiliser le même identifiant de fournisseur que pour les récupérer.
Demander des identifiants stockés
Après avoir créé les objets CredentialsClient
et CredentialRequest
, transmettez-les à la méthode CredentialsClient.request()
pour demander les identifiants stockés pour votre application.
mCredentialsClient.request(mCredentialRequest).addOnCompleteListener(
new OnCompleteListener<CredentialRequestResponse>() {
@Override
public void onComplete(@NonNull Task<CredentialRequestResponse> task) {
if (task.isSuccessful()) {
// See "Handle successful credential requests"
onCredentialRetrieved(task.getResult().getCredential());
return;
}
// See "Handle unsuccessful and incomplete credential requests"
// ...
}
});
Définissez un rappel pour gérer les requêtes ayant abouti et celles ayant échoué à l'aide de la méthode addOnCompleteListener()
.
Gérer les requêtes d'identification réussies
Lorsqu'une requête d'identifiant aboutit, utilisez l'objet Credential
obtenu pour terminer la connexion de l'utilisateur à votre application. Utilisez la méthode getAccountType()
pour déterminer le type d'identifiants récupérés, puis terminez le processus de connexion approprié. Par exemple, pour Google Sign-In, créez un objet GoogleSignInClient
qui inclut l'ID de l'utilisateur, puis utilisez-le pour démarrer le flux de connexion. Pour la connexion par mot de passe, terminez le processus de connexion à votre application à l'aide de l'ID et du mot de passe de l'utilisateur issus de l'objet Identifiant.
private void onCredentialRetrieved(Credential credential) {
String accountType = credential.getAccountType();
if (accountType == null) {
// Sign the user in with information from the Credential.
signInWithPassword(credential.getId(), credential.getPassword());
} else if (accountType.equals(IdentityProviders.GOOGLE)) {
// The user has previously signed in with Google Sign-In. Silently
// sign in the user with the same ID.
// See https://developers.google.com/identity/sign-in/android/
GoogleSignInOptions gso =
new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
.requestEmail()
.build();
GoogleSignInClient signInClient = GoogleSignIn.getClient(this, gso);
Task<GoogleSignInAccount> task = signInClient.silentSignIn();
// ...
}
}
Gérer plusieurs identifiants enregistrés
Lorsqu'une entrée utilisateur est requise pour sélectionner un identifiant, la tâche request()
échoue avec une erreur ResolvableApiException
. Vérifiez que getStatusCode()
renvoie RESOLUTION_REQUIRED
et appelez la méthode startResolutionForResult()
de l'exception pour inviter l'utilisateur à choisir un compte. Ensuite, récupérez les identifiants choisis par l'utilisateur à partir de la méthode onActivityResult()
de l'activité en transmettant Credential.EXTRA_KEY
à la méthode getParcelableExtra()
.
mCredentialsClient.request(request).addOnCompleteListener( new OnCompleteListener() { @Override public void onComplete(@NonNull Task task) { if (task.isSuccessful()) { // ... return; } Exception e = task.getException(); if (e instanceof ResolvableApiException) { // This is most likely the case where the user has multiple saved // credentials and needs to pick one. This requires showing UI to // resolve the read request. ResolvableApiException rae = (ResolvableApiException) e; resolveResult(rae, RC_READ); } else if (e instanceof ApiException) { // The user must create an account or sign in manually. Log.e(TAG, "Unsuccessful credential request.", e); ApiException ae = (ApiException) e; int code = ae.getStatusCode(); // ... } } });
private void resolveResult(ResolvableApiException rae, int requestCode) {
try {
rae.startResolutionForResult(MainActivity.this, requestCode);
mIsResolving = true;
} catch (IntentSender.SendIntentException e) {
Log.e(TAG, "Failed to send resolution.", e);
hideProgress();
}
}
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
// ...
if (requestCode == RC_READ) {
if (resultCode == RESULT_OK) {
Credential credential = data.getParcelableExtra(Credential.EXTRA_KEY);
onCredentialRetrieved(credential);
} else {
Log.e(TAG, "Credential Read: NOT OK");
Toast.makeText(this, "Credential Read Failed", Toast.LENGTH_SHORT).show();
}
}
// ...
}
Lorsque les identifiants stockés ne sont pas trouvés, les utilisateurs doivent créer un compte ou se connecter manuellement. Si getStatusCode()
renvoie SIGN_IN_REQUIRED
, vous pouvez éventuellement accélérer les processus d'inscription et de connexion en invitant l'utilisateur à choisir les informations de connexion récemment utilisées, telles que l'adresse e-mail et le nom, et en remplissant automatiquement certains champs des formulaires.
Pour en savoir plus, consultez Fournir des indications de connexion à un utilisateur.
En cas de connexion réussie, autorisez les utilisateurs à enregistrer leurs identifiants pour automatiser la future authentification sur tous leurs appareils.