Récupérer les identifiants enregistrés d'un utilisateur

Obsolète:Smart Lock pour les mots de passe est obsolète. Pour assurer la sécurité et la facilité d'utilisation de votre application, migrez vers le Gestionnaire d'identifiants dès aujourd'hui. Le Gestionnaire d'identifiants est compatible avec l'authentification par clé d'accès, mot de passe et identité fédérée (par exemple, Se connecter avec Google), renforce la sécurité et propose une expérience utilisateur plus cohérente.

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();
        // ...
    }
}

Si l'ID d'un identifiant récupéré correspond à l'ID d'un compte connecté sur l'appareil, le justificatif contiendra un jeton d'identification que vous pourrez utiliser pour vous authentifier sans mot de passe. Consultez Se connecter à l'aide de jetons d'ID.

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.