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
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
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.