Recuperar las credenciales almacenadas de un usuario

Permite que los usuarios accedan automáticamente a tu app con la API de Credentials para solicitar y recuperar credenciales almacenadas para tus usuarios.

Antes de comenzar

Configura un proyecto de Android Studio.

Crea un objeto CredentialsClient

Para solicitar credenciales almacenadas, debes crear una instancia de CredentialsClient para acceder a la API de credenciales:

CredentialsClient mCredentialsClient;

// ...

mCredentialsApiClient = Credentials.getClient(this);

Crea un objeto CredentialRequest

Un objeto CredentialRequest especifica la de acceso a los sistemas desde los que deseas solicitar credenciales. Crea un CredentialRequest con el método setPasswordLoginSupported para y el método setAccountTypes() para cuentas federadas servicios de acceso, como Acceso con Google.

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

Usa las constantes definidas en IdentityProviders. para especificar los proveedores de acceso de uso general. Para otros proveedores de acceso, usa cualquier cadena que identifica de forma única al proveedor. Debes usar el mismo identificador de proveedor para almacenar las credenciales a medida que las usas para recuperarlas.

Solicita credenciales almacenadas

Después de crear los objetos CredentialsClient y CredentialRequest, pasa el objeto de solicitud. a la CredentialsClient.request() para solicitar las credenciales almacenadas para tu app.

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

Define una devolución de llamada para controlar las solicitudes exitosas y fallidas con el addOnCompleteListener().

Maneja solicitudes de credenciales correctas

Aviso que indica un acceso exitoso En una solicitud de credencial exitosa, usa el resultado Credential objeto para completar el acceso del usuario a tu app. Usa el método getAccountType() para determinar el tipo de credenciales recuperadas y, luego, completa los pasos el proceso de administración de recursos. Por ejemplo, para el Acceso con Google, crea un objeto GoogleSignInClient que incluye el ID del usuario y, luego, usarás el objeto para iniciar el flujo de acceso. Basado en contraseña acceder, usar el ID y la contraseña del usuario del objeto de credencial para completar el de acceso.

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

Administra varias credenciales guardadas

Selector de cuentas de Smart Lock

Cuando se requiere la entrada del usuario para seleccionar una credencial, la tarea request() fallan con un ResolvableApiException. Comprueba que getStatusCode() muestra RESOLUTION_REQUIRED y llama al método startResolutionForResult() de la excepción para solicitarle al usuario para elegir una cuenta. Luego, recupera las credenciales elegidas por el usuario del método onActivityResult() de la actividad pasando Credential.EXTRA_KEY al 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();
        }
    }

    // ...

}

Cuando no se encuentran credenciales almacenadas, los usuarios deben crear una cuenta o accede a tu cuenta. Si es getStatusCode() muestra SIGN_IN_REQUIRED, Si lo deseas, puedes acelerar los procesos de registro y acceso indicando al que el usuario elija la información de acceso utilizada recientemente, como la dirección de correo electrónico y y completará automáticamente algunos campos de los formularios con esa información. Consulta Cómo proporcionar sugerencias de acceso a un usuario. para conocer los detalles.

Después de acceder correctamente, permite que los usuarios guarden sus credenciales para automatizar la autenticación futura en todos sus dispositivos.