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

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 les 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 de la méthode setAccountTypes() pour les services de connexion fédérés 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 les identifie de manière unique. Vous devez utiliser le même identifiant de fournisseur pour stocker les identifiants que pour récupérer les identifiants.

Demander les identifiants stockés

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

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

Lorsque la requête d'identification aboutit, utilisez l'objet Credential pour vous connecter à votre application. Utilisez la méthode getAccountType() pour déterminer le type d'identifiants récupérés, puis effectuez le processus de connexion approprié. Par exemple, pour Google Sign-In, créez un objet GoogleSignInClient incluant l'ID de l'utilisateur, puis utilisez-le pour démarrer le flux de connexion. Pour la connexion par mot de passe, utilisez l'ID d'utilisateur et le mot de passe de l'objet Credential pour terminer la procédure de connexion de votre application.

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 des identifiants, la tâche request() échoue avec un ResolvableApiException. Vérifiez que getStatusCode() renvoie RESOLUTION_REQUIRED et appelez la méthode startResolutionForResult() d'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 sont introuvables, les utilisateurs doivent créer un compte ou se connecter manuellement. Si getStatusCode() renvoie SIGN_IN_REQUIRED, vous pouvez accélérer les processus d'inscription et de connexion. Pour ce faire, invitez l'utilisateur à choisir des informations de connexion récemment utilisées, telles que son adresse e-mail et son nom, et remplissez automatiquement certains champs des formulaires. Pour en savoir plus, consultez Fournir des conseils de connexion à un utilisateur.

Une fois la connexion établie, autorisez les utilisateurs à enregistrer leurs identifiants pour automatiser l'authentification future sur tous leurs appareils.