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

<ph type="x-smartling-placeholder">

</ph> Obsolète: Smart Lock pour les mots de passe est obsolète. Pour vous assurer que la sécurité et la facilité d'utilisation de votre application, migrer vers Gestionnaire d'identifiants. Le Gestionnaire d'identifiants prend en charge les clés d'accès, les mots de passe, et l'authentification par identité fédérée (comme Se connecter avec Google), une sécurité renforcée et une expérience utilisateur plus cohérente.

Connecter automatiquement les utilisateurs à votre application à l'aide de l'API Credentials pour demander et 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 des systèmes de connexion auxquels vous souhaitez demander des identifiants. Créez un CredentialRequest à l'aide de la méthode setPasswordLoginSupported pour la connexion par mot de passe, et la méthode setAccountTypes() pour les connexions fédérées de services de connexion tels que Google Sign-In.

mCredentialRequest = new CredentialRequest.Builder()
    .setPasswordLoginSupported(true)
    .setAccountTypes(IdentityProviders.GOOGLE, IdentityProviders.TWITTER)
    .build();

Utiliser les constantes définies dans IdentityProviders pour spécifier les fournisseurs de connexion couramment utilisés. Pour les autres fournisseurs de connexion, utilisez qui identifie le fournisseur de manière unique. Vous devez utiliser le même identifiant de fournisseur pour stocker les identifiants lorsque vous les utilisez pour les récupérer.

Demander les identifiants stockés

Après avoir créé les objets CredentialsClient et CredentialRequest, transmettez l'objet de requête à la 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 ayant échoué à l'aide de la méthode addOnCompleteListener().

Gérer les requêtes d'identifiants réussies

En cas de demande d'identifiants réussie, utilisez le résultat Credential pour finaliser la connexion de l'utilisateur à votre application. Utiliser la méthode getAccountType() pour déterminer le type d'identifiants récupérés, puis connectez-vous de manière appropriée processus. Par exemple, pour Google Sign-In, créez un objet GoogleSignInClient qui inclut l'ID de l'utilisateur, puis utilisez l'objet pour lancer le flux de connexion. Pour les mots de passe utilisez l'ID et le mot de passe de l'objet "Credential" pour effectuer l'opération processus de connexion.

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'identifiant d'un jeu d'identification récupéré correspond à l'identifiant d'un connecté à l'appareil, l'identifiant contiendra un jeton d'identification qui que vous pouvez utiliser pour vous authentifier sans mot de passe. Voir <ph type="x-smartling-placeholder"></ph> 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() échouent avec une ResolvableApiException. Vérifiez que getStatusCode() renvoie RESOLUTION_REQUIRED et appeler la méthode startResolutionForResult() de l'exception pour inviter l'utilisateur ; pour choisir un compte. Ensuite, récupérez les identifiants choisis par l'utilisateur à partir du la méthode onActivityResult() de l'activité en transmettant Credential.EXTRA_KEY à la 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 sont introuvables, les utilisateurs doivent créer un compte ou connectez-vous. Si getStatusCode() renvoie SIGN_IN_REQUIRED, vous pouvez, si vous le souhaitez, accélérer les processus d'inscription et de connexion en affichant une invite à choisir les informations de connexion récemment utilisées, telles que l'adresse e-mail et et remplir automatiquement certains champs des formulaires avec cette information. Consultez Fournir des conseils de connexion à l'utilisateur. pour en savoir plus.

Une fois la connexion établie, autorisez les utilisateurs à enregistrer leurs identifiants. pour automatiser les futures authentifications sur tous leurs appareils.