Puedes usar Firebase Authentication para hacer que un usuario acceda mediante el envío de un mensaje SMS a su teléfono. El usuario accede con un código único que se incluye en el mensaje SMS.
La forma más fácil de agregar un acceso con número de teléfono a la app es usar FirebaseUI, que incluye un widget de acceso directo que implementa flujos de acceso con número de teléfono, además de acceso federado y con contraseña. En este documento, se describe cómo implementar un flujo de acceso con el número de teléfono mediante el SDK de Firebase.
Antes de comenzar
- Si aún no lo has hecho, agrega Firebase a tu proyecto de Android.
-
En el archivo de Gradle (generalmente
<project>/<app-module>/build.gradle.ktso<project>/<app-module>/build.gradle) del módulo (a nivel de app), agrega la dependencia de la biblioteca de Android para Firebase Authentication. Te recomendamos usar la BoM de Firebase para Android para controlar las versiones de las bibliotecas.Kotlin+KTX
dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:32.3.1")) // Add the dependency for the Firebase Authentication library // When using the BoM, you don't specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-auth-ktx") }Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.
(Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM
Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.
Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que utilices la BoM para administrar las versiones de las bibliotecas para garantizar que todas las versiones sean compatibles.
dependencies { // Add the dependency for the Firebase Authentication library // When NOT using the BoM, you must specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-auth-ktx:22.1.2") }Java
dependencies { // Import the BoM for the Firebase platform implementation(platform("com.google.firebase:firebase-bom:32.3.1")) // Add the dependency for the Firebase Authentication library // When using the BoM, you don't specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-auth") }Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.
(Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM
Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.
Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que utilices la BoM para administrar las versiones de las bibliotecas a fin de garantizar que todas las versiones sean compatibles.
dependencies { // Add the dependency for the Firebase Authentication library // When NOT using the BoM, you must specify versions in Firebase library dependencies implementation("com.google.firebase:firebase-auth:22.1.2") } - Si aún no has conectado la app al proyecto de Firebase, puedes hacerlo desde Firebase console.
- Si aún no has configurado el hash SHA-1 de tu app, hazlo en Firebase console. Consulta Autentica tu cliente para obtener información sobre cómo encontrar el hash SHA-1 de tu app.
Preocupaciones de seguridad
Si bien la autenticación con solo un número de teléfono es conveniente, es menos segura que otros métodos disponibles, ya que la posesión de un número de teléfono se puede transferir con facilidad entre usuarios. Además, en los dispositivos con varios perfiles de usuario, cualquier usuario que reciba mensajes SMS puede acceder a una cuenta con el número de teléfono del dispositivo.
Si usas el acceso con número de teléfono en la app, deberías ofrecerlo junto con métodos de acceso más seguros, además de informar a los usuarios acerca de las desventajas de usar el acceso con número de teléfono.
Habilita el acceso con número de teléfono para el proyecto de Firebase
Para que los usuarios accedan a través de SMS, primero debes habilitar el método de acceso con el número de teléfono para el proyecto de Firebase:
- En Firebase console, abre la sección Authentication.
- En la página de método de acceso, habilita el método de acceso Número de teléfono.
La cuota de solicitudes de acceso con el número de teléfono de Firebase es lo suficientemente alta para que la mayoría de las apps no tengan problemas. Sin embargo, si necesitas permitir el acceso de un gran volumen de usuarios con autenticación por teléfono, es posible que debas actualizar tu plan de precios. Consulta la página de precios.
Habilita la verificación de la app
Para usar la autenticación con número de teléfono, Firebase debe poder verificar que las solicitudes de acceso con número de teléfono provienen de la app. Firebase Authentication hace lo anterior de tres maneras:
- API de Play Integrity: Si un usuario cuenta con un dispositivo que tiene instalados los Servicios de Google Play y
Firebase Authentication puede verificarlo como legítimo con la
API de Play Integrity,
el acceso con número de teléfono puede continuar. Firebase Authentication habilita la API de Play Integrity en un proyecto de Google,
no en el tuyo. Esto no contribuye a ninguna cuota de la API de Play Integrity
en tu proyecto. La compatibilidad para Play Integrity está disponible a partir de la
versión 21.2.0 del SDK de Authentication
(versión 31.4.0 o superior de la BoM de Firebase).
Si quieres usar Play Integrity y aún no has especificado la huella digital SHA-256 de tu app, hazlo desde la Configuración del proyecto de Firebase console. Consulta Autenticación de tu cliente para obtener detalles sobre cómo obtener la huella digital SHA-256 de tu app.
- Verificación de reCAPTCHA: En el caso de que no sea posible usar Play Integrity
(por ejemplo, cuando el dispositivo del usuario no tenga instalados los Servicios de Google Play), Firebase Authentication
utiliza una verificación de reCAPTCHA para completar el flujo del acceso con número de teléfono. El desafío de reCAPTCHA a menudo se puede
completar sin que el usuario tenga que resolver nada. Ten en cuenta que este flujo requiere que se asocie un hash SHA‑1
a tu aplicación. Este flujo también requiere que tu clave de API
no tenga restricciones o que se incluya en la lista de entidades permitidas de
PROJECT_ID.firebaseapp.com.Estas son algunas situaciones en las que se activa reCAPTCHA:
- Si el dispositivo del usuario final no tiene instalados los Servicios de Google Play.
- Si la app no se distribuye en Google Play Store (en el SDK de Authentication v21.2.0 o una versión posterior).
- Si el token de SafetyNet no es válido (en versiones del SDK de Authentication anteriores a la v21.2.0).
Cuando se usa SafetyNet o Play Integrity para la verificación de apps, se propaga el campo
%APP_NAME%en la plantilla de SMS con el nombre de la app que se determina en Google Play Store. En los casos en que se activa reCAPTCHA,%APP_NAME%se propaga comoPROJECT_ID.firebaseapp.com.
forceRecaptchaFlowForTesting.
Para inhabilitar la verificación de la app (cuando se usan números de teléfono ficticios), utiliza
setAppVerificationDisabledForTesting.
Soluciona problemas
Error que indica que “falta el estado inicial” cuando se usa reCAPTCHA para la verificación de la app
Esto puede ocurrir cuando el flujo de reCAPTCHA se completa correctamente, pero no redirecciona al usuario de vuelta a la aplicación nativa. Si esto ocurre, se redirecciona al usuario a la URL de resguardo
PROJECT_ID.firebaseapp.com/__/auth/handler. En los navegadores Firefox, la opción para abrir vínculos de apps nativas está inhabilitada de forma predeterminada. Si ves el error anterior en Firefox, sigue los pasos que se indican en Configura Firefox para que abra vínculos en apps nativas a fin de habilitarlos.
Envía un código de verificación al teléfono del usuario
Para iniciar el acceso con número de teléfono, muéstrale al usuario una interfaz que le pida ingresar su número de teléfono. Los requisitos legales varían, pero es recomendable establecer las expectativas de los usuarios informándoles que, si usan el acceso con el teléfono, es posible que reciban un mensaje SMS para la verificación y que se apliquen las tarifas estándar.
Luego, pasa el número de teléfono del usuario al método PhoneAuthProvider.verifyPhoneNumber para solicitar que Firebase lo verifique. Por ejemplo:
Kotlin+KTX
val options = PhoneAuthOptions.newBuilder(auth)
.setPhoneNumber(phoneNumber) // Phone number to verify
.setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
.setActivity(this) // Activity (for callback binding)
.setCallbacks(callbacks) // OnVerificationStateChangedCallbacks
.build()
PhoneAuthProvider.verifyPhoneNumber(options)
Java
PhoneAuthOptions options =
PhoneAuthOptions.newBuilder(mAuth)
.setPhoneNumber(phoneNumber) // Phone number to verify
.setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
.setActivity(this) // (optional) Activity for callback binding
// If no activity is passed, reCAPTCHA verification can not be used.
.setCallbacks(mCallbacks) // OnVerificationStateChangedCallbacks
.build();
PhoneAuthProvider.verifyPhoneNumber(options);
El método verifyPhoneNumber es reentrante: si lo llamas
varias veces, como en el método onStart de una actividad, el método
verifyPhoneNumber no enviará un segundo SMS, a menos que la
solicitud original haya agotado el tiempo de espera.
Puedes usar este comportamiento para reanudar el proceso de acceso con número de teléfono en caso de que tu app se cierre antes de que el usuario pueda acceder a ella (por ejemplo, cuando el usuario use su app de SMS). Después de llamar a verifyPhoneNumber, configura una marca que indique que la verificación está en progreso. Luego, guarda la marca en el método onSaveInstanceState de tu actividad y restablece la marca en onRestoreInstanceState. Finalmente, en el método onStart de tu actividad, comprueba si la verificación ya está en curso y, de ser así, llama nuevamente a verifyPhoneNumber. Asegúrate de borrar la marca cuando la verificación finalice o no se realice correctamente (consulta las devoluciones de llamada de verificación).
A fin de manejar fácilmente la rotación de pantalla y otros casos de reinicio de la actividad, pásala al método verifyPhoneNumber. Las devoluciones de llamada se desvincularán automáticamente cuando se detenga la actividad, a fin de que puedas escribir el código de transición de la IU con libertad en los métodos de devolución de llamada.
El mensaje SMS que envía Firebase también puede localizarse si especificas el
idioma de autenticación a través del método setLanguageCode en tu instancia
de Auth.
Kotlin+KTX
auth.setLanguageCode("fr")
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage()
Java
auth.setLanguageCode("fr");
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage();
Cuando llames a PhoneAuthProvider.verifyPhoneNumber, también deberás
proporcionar una instancia de OnVerificationStateChangedCallbacks que
contenga implementaciones de las funciones de devolución de llamada que administran los resultados de
la solicitud. Por ejemplo:
Kotlin+KTX
callbacks = object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
override fun onVerificationCompleted(credential: PhoneAuthCredential) {
// This callback will be invoked in two situations:
// 1 - Instant verification. In some cases the phone number can be instantly
// verified without needing to send or enter a verification code.
// 2 - Auto-retrieval. On some devices Google Play services can automatically
// detect the incoming verification SMS and perform verification without
// user action.
Log.d(TAG, "onVerificationCompleted:$credential")
signInWithPhoneAuthCredential(credential)
}
override fun onVerificationFailed(e: FirebaseException) {
// This callback is invoked in an invalid request for verification is made,
// for instance if the the phone number format is not valid.
Log.w(TAG, "onVerificationFailed", e)
if (e is FirebaseAuthInvalidCredentialsException) {
// Invalid request
} else if (e is FirebaseTooManyRequestsException) {
// The SMS quota for the project has been exceeded
} else if (e is FirebaseAuthMissingActivityForRecaptchaException) {
// reCAPTCHA verification attempted with null Activity
}
// Show a message and update the UI
}
override fun onCodeSent(
verificationId: String,
token: PhoneAuthProvider.ForceResendingToken,
) {
// The SMS verification code has been sent to the provided phone number, we
// now need to ask the user to enter the code and then construct a credential
// by combining the code with a verification ID.
Log.d(TAG, "onCodeSent:$verificationId")
// Save verification ID and resending token so we can use them later
storedVerificationId = verificationId
resendToken = token
}
}
Java
mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
@Override
public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
// This callback will be invoked in two situations:
// 1 - Instant verification. In some cases the phone number can be instantly
// verified without needing to send or enter a verification code.
// 2 - Auto-retrieval. On some devices Google Play services can automatically
// detect the incoming verification SMS and perform verification without
// user action.
Log.d(TAG, "onVerificationCompleted:" + credential);
signInWithPhoneAuthCredential(credential);
}
@Override
public void onVerificationFailed(@NonNull FirebaseException e) {
// This callback is invoked in an invalid request for verification is made,
// for instance if the the phone number format is not valid.
Log.w(TAG, "onVerificationFailed", e);
if (e instanceof FirebaseAuthInvalidCredentialsException) {
// Invalid request
} else if (e instanceof FirebaseTooManyRequestsException) {
// The SMS quota for the project has been exceeded
} else if (e instanceof FirebaseAuthMissingActivityForRecaptchaException) {
// reCAPTCHA verification attempted with null Activity
}
// Show a message and update the UI
}
@Override
public void onCodeSent(@NonNull String verificationId,
@NonNull PhoneAuthProvider.ForceResendingToken token) {
// The SMS verification code has been sent to the provided phone number, we
// now need to ask the user to enter the code and then construct a credential
// by combining the code with a verification ID.
Log.d(TAG, "onCodeSent:" + verificationId);
// Save verification ID and resending token so we can use them later
mVerificationId = verificationId;
mResendToken = token;
}
};
Devoluciones de llamada de verificación
En la mayoría de las apps, deberás implementar las devoluciones de llamada onVerificationCompleted, onVerificationFailed y onCodeSent. Sin embargo, según los requisitos de tu app, también puedes implementar onCodeAutoRetrievalTimeOut.
onVerificationCompleted(PhoneAuthCredential)
Este método se llama en dos situaciones:
- Verificación instantánea: En algunos casos, el número de teléfono se puede verificar de manera instantánea, sin necesidad de enviar o ingresar un código de verificación.
- Recuperación automática: En ciertos dispositivos, Servicios de Google Play puede detectar automáticamente el SMS de verificación entrante y realizar la verificación sin que el usuario intervenga. Tal vez esta opción no se encuentre disponible con algunos proveedores. Para ello, se usa la API de SMS Retriever, que incluye un hash de 11 caracteres al final del SMS.
PhoneAuthCredential que se pasó a
la
devolución de llamada para que el usuario acceda.
onVerificationFailed(FirebaseException)
Este método se llama como respuesta a una solicitud de verificación no válida, como una solicitud que especifica un número de teléfono o un código de verificación no válido.
onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)
Opcional. Este método se llama luego de enviar por SMS el código de verificación al número de teléfono proporcionado.
Cuando se llama este método, la mayoría de las apps muestran una IU que le pide al usuario escribir el código de verificación que recibió por SMS. La verificación se podría estar realizando en segundo plano al mismo tiempo. Después de que el usuario escriba el código de verificación, puedes usar el código y el ID de verificación que se pasaron al método para crear un objeto PhoneAuthCredential, que a su vez puedes usar para que el usuario acceda. Sin embargo, es posible que algunas apps esperen hasta que se llame a onCodeAutoRetrievalTimeOut para mostrar la IU del código de verificación (no se recomienda).
onCodeAutoRetrievalTimeOut(String verificationId)
Opcional. Este método se llama después de que haya pasado el tiempo de espera especificado en verifyPhoneNumber sin que se active onVerificationCompleted primero. En los dispositivos que no tienen tarjeta SIM, este método se llama de inmediato, debido a que no se puede realizar una recuperación automática de SMS.
Algunas apps bloquean los datos de entrada del usuario hasta que termine el tiempo de espera del período de verificación automática y solo en ese momento muestran una IU que le pide al usuario escribir el código de verificación que recibió por SMS (no se recomienda).
Crea un objeto PhoneAuthCredential
Después de que el usuario ingrese el código de verificación que Firebase envió al teléfono del usuario, crea un objeto PhoneAuthCredential con el código y el ID de verificación que se pasaron a la devolución de llamada onCodeSent o onCodeAutoRetrievalTimeOut. (Cuando se llama a onVerificationCompleted, se obtiene un objeto PhoneAuthCredential directamente, por lo que puedes omitir este paso).
Para crear el objeto PhoneAuthCredential, llama
al PhoneAuthProvider.getCredential:
Kotlin+KTX
val credential = PhoneAuthProvider.getCredential(verificationId!!, code)
Java
PhoneAuthCredential credential = PhoneAuthProvider.getCredential(verificationId, code);
Acceso del usuario
Después de que recibas un objeto PhoneAuthCredential, ya sea en la
devolución de llamada onVerificationCompleted o mediante la llamada a
PhoneAuthProvider.getCredential, pasa el objeto PhoneAuthCredential
a FirebaseAuth.signInWithCredential para completar
el flujo de acceso:
Kotlin+KTX
private fun signInWithPhoneAuthCredential(credential: PhoneAuthCredential) {
auth.signInWithCredential(credential)
.addOnCompleteListener(this) { task ->
if (task.isSuccessful) {
// Sign in success, update UI with the signed-in user's information
Log.d(TAG, "signInWithCredential:success")
val user = task.result?.user
} else {
// Sign in failed, display a message and update the UI
Log.w(TAG, "signInWithCredential:failure", task.exception)
if (task.exception is FirebaseAuthInvalidCredentialsException) {
// The verification code entered was invalid
}
// Update UI
}
}
}
Java
private void signInWithPhoneAuthCredential(PhoneAuthCredential credential) {
mAuth.signInWithCredential(credential)
.addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
@Override
public void onComplete(@NonNull Task<AuthResult> task) {
if (task.isSuccessful()) {
// Sign in success, update UI with the signed-in user's information
Log.d(TAG, "signInWithCredential:success");
FirebaseUser user = task.getResult().getUser();
// Update UI
} else {
// Sign in failed, display a message and update the UI
Log.w(TAG, "signInWithCredential:failure", task.getException());
if (task.getException() instanceof FirebaseAuthInvalidCredentialsException) {
// The verification code entered was invalid
}
}
}
});
}
Realiza pruebas con números de teléfono ficticios
Puedes configurar números de teléfono ficticios para el desarrollo con Firebase console. Las pruebas con este tipo de números de teléfono brindan los siguientes beneficios:
- Permiten probar la autenticación de números de teléfono sin consumir tu cuota de uso.
- Permiten probar la autenticación de números de teléfono sin enviar SMS reales.
- Ejecutan pruebas consecutivas con el mismo número de teléfono sin límites. Esto minimiza el riesgo de rechazo durante el proceso de revisión de la tienda de aplicaciones si el revisor utiliza el mismo número de teléfono para las pruebas.
- Realizan pruebas con facilidad en entornos de desarrollo sin ningún esfuerzo adicional. Por ejemplo, puedes tener la capacidad de desarrollar en un simulador de iOS o un emulador de Android sin los Servicios de Google Play.
- Permiten escribir pruebas de integración sin recibir bloqueos por controles de seguridad que se suelen aplicar a los números de teléfono reales en un entorno de producción.
Los números de teléfono ficticios deben cumplir los siguientes requisitos:
- Asegúrate de usar números de teléfono que sean ficticios y que aún no existan. Firebase Authentication no permite establecer como números de prueba los teléfonos existentes que tengan usuarios reales. Una opción es usar números con el prefijo 555 como números de teléfono de prueba de EE.UU., por ejemplo: +1 650‑555‑3434.
- Los números de teléfono deben tener el formato adecuado de longitud y otras restricciones. Estos números pasarán por la misma validación que el número de teléfono de un usuario real.
- Puedes agregar hasta 10 números de teléfono.
- Usa códigos o números de teléfono de prueba que sean difíciles de adivinar y cámbialos con frecuencia.
Crea números de teléfono y códigos de verificación ficticios
- En Firebase console, abre la sección Authentication.
- En la pestaña Método de acceso, habilita el proveedor de telefonía, si todavía no lo has hecho.
- Abre el menú de acordeón Números de teléfono para la prueba.
- Proporciona el número de teléfono que deseas probar, por ejemplo: +1 650-555-3434.
- Proporciona el código de verificación de 6 dígitos para ese número específico, por ejemplo: 654321.
- Agrega el número. Si es necesario, puedes desplazarte sobre la fila correspondiente y hacer clic en el ícono de papelera para borrar el número de teléfono y su código.
Realiza pruebas manuales
Puedes comenzar a usar un número de teléfono ficticio en tu aplicación directamente. Esto te permite realizar pruebas manuales durante las etapas de desarrollo sin que te encuentres con problemas de cuota o de límites. También puedes realizar pruebas directamente desde un simulador de iOS o un emulador de Android sin tener instalados los Servicios de Google Play.
Cuando proporcionas el número de teléfono ficticio y envías el código de verificación, no se envía ningún SMS real. En lugar de eso, debes proporcionar el código de verificación previamente configurado para completar el acceso.
Cuando se completa el acceso, se crea un usuario de Firebase con ese número de teléfono. El usuario tiene el mismo comportamiento y las mismas propiedades que el usuario de un número de teléfono real, y puede acceder de la misma manera a Realtime Database, Cloud Firestore y otros servicios. El token de ID emitido durante este proceso tiene la misma firma que el usuario de un número de teléfono real.
Otra opción es configurar una función de prueba mediante reclamaciones personalizadas en estos usuarios para diferenciarlos como usuarios falsos si quieres restringir más el acceso.
Usa el método forceRecaptchaFlowForTesting() si quieres activar de forma manual el flujo de reCAPTCHA para las pruebas.
// Force reCAPTCHA flow FirebaseAuth.getInstance().getFirebaseAuthSettings().forceRecaptchaFlowForTesting();
Realiza pruebas de integración
Además de las pruebas manuales, Firebase Authentication proporciona las API con las que es posible escribir pruebas de integración para la autenticación del teléfono. Estas API desactivan la verificación de la app cuando inhabilitan el requisito de reCAPTCHA en la Web y en las notificaciones push silenciosas en iOS. Esto hace que las pruebas de automatización sean posibles en estos flujos y más fáciles de implementar. Además, las API proporcionan la capacidad de probar flujos de verificación instantánea en Android.
En Android, llama a setAppVerificationDisabledForTesting() antes de realizar la llamada a signInWithPhoneNumber. Esta acción inhabilita la verificación de apps de forma automática,
lo que te permite pasar el número de teléfono sin tener que resolverlo de forma manual. Si bien
Play Integrity y reCAPTCHA están inhabilitados, el uso de un número de teléfono real no
completará el acceso. Con esta API, solo se pueden usar números de teléfono ficticios.
// Turn off phone auth app verification. FirebaseAuth.getInstance().getFirebaseAuthSettings() .setAppVerificationDisabledForTesting();
Llamar a verifyPhoneNumber con un número de teléfono ficticio activa la devolución de llamada onCodeSent, en la que deberás proporcionar el código de verificación correspondiente. Esto permite realizar pruebas en emuladores de Android.
Java
String phoneNum = "+16505554567";
String testVerificationCode = "123456";
// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
FirebaseAuth auth = FirebaseAuth.getInstance();
PhoneAuthOptions options = PhoneAuthOptions.newBuilder(auth)
.setPhoneNumber(phoneNum)
.setTimeout(60L, TimeUnit.SECONDS)
.setActivity(this)
.setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
@Override
public void onCodeSent(@NonNull String verificationId,
@NonNull PhoneAuthProvider.ForceResendingToken forceResendingToken) {
// Save the verification id somewhere
// ...
// The corresponding whitelisted code above should be used to complete sign-in.
MainActivity.this.enableUserManuallyInputCode();
}
@Override
public void onVerificationCompleted(@NonNull PhoneAuthCredential phoneAuthCredential) {
// Sign in with the credential
// ...
}
@Override
public void onVerificationFailed(@NonNull FirebaseException e) {
// ...
}
})
.build();
PhoneAuthProvider.verifyPhoneNumber(options);
Kotlin+KTX
val phoneNum = "+16505554567"
val testVerificationCode = "123456"
// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
val options = PhoneAuthOptions.newBuilder(Firebase.auth)
.setPhoneNumber(phoneNum)
.setTimeout(30L, TimeUnit.SECONDS)
.setActivity(this)
.setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
override fun onCodeSent(
verificationId: String,
forceResendingToken: PhoneAuthProvider.ForceResendingToken,
) {
// Save the verification id somewhere
// ...
// The corresponding whitelisted code above should be used to complete sign-in.
this@MainActivity.enableUserManuallyInputCode()
}
override fun onVerificationCompleted(phoneAuthCredential: PhoneAuthCredential) {
// Sign in with the credential
// ...
}
override fun onVerificationFailed(e: FirebaseException) {
// ...
}
})
.build()
PhoneAuthProvider.verifyPhoneNumber(options)
Además, puedes probar los flujos de recuperación automática en Android. Para ello, configura el número de teléfono ficticio y
su código de verificación correspondiente para la recuperación automática mediante una llamada a
setAutoRetrievedSmsCodeForPhoneNumber.
Cuando se llama a verifyPhoneNumber, se activa onVerificationCompleted con el PhoneAuthCredential directamente. Esto funciona solo con números de teléfono ficticios.
Asegúrate de que la opción esté inhabilitada y que ningún número de teléfono ficticio esté codificado en tu app cuando la publiques en Google Play Store.
Java
// The test phone number and code should be whitelisted in the console.
String phoneNumber = "+16505554567";
String smsCode = "123456";
FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
FirebaseAuthSettings firebaseAuthSettings = firebaseAuth.getFirebaseAuthSettings();
// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode);
PhoneAuthOptions options = PhoneAuthOptions.newBuilder(firebaseAuth)
.setPhoneNumber(phoneNumber)
.setTimeout(60L, TimeUnit.SECONDS)
.setActivity(this)
.setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
@Override
public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
// Instant verification is applied and a credential is directly returned.
// ...
}
// ...
})
.build();
PhoneAuthProvider.verifyPhoneNumber(options);
Kotlin+KTX
// The test phone number and code should be whitelisted in the console.
val phoneNumber = "+16505554567"
val smsCode = "123456"
val firebaseAuth = Firebase.auth
val firebaseAuthSettings = firebaseAuth.firebaseAuthSettings
// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode)
val options = PhoneAuthOptions.newBuilder(firebaseAuth)
.setPhoneNumber(phoneNumber)
.setTimeout(60L, TimeUnit.SECONDS)
.setActivity(this)
.setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
override fun onVerificationCompleted(credential: PhoneAuthCredential) {
// Instant verification is applied and a credential is directly returned.
// ...
}
// ...
})
.build()
PhoneAuthProvider.verifyPhoneNumber(options)
Próximos pasos
Cuando un usuario accede por primera vez, se crea una cuenta de usuario nueva y se la vincula con las credenciales (el nombre de usuario y la contraseña, el número de teléfono o la información del proveedor de autenticación) que el usuario utilizó para acceder. Esta cuenta nueva se almacena como parte de tu proyecto de Firebase y se puede usar para identificar a un usuario en todas las apps del proyecto, sin importar cómo acceda.
-
En tus apps, puedes obtener la información básica del perfil del usuario a partir del objeto
FirebaseUser. Consulta Administra usuarios. En tus reglas de seguridad de Firebase Realtime Database y Cloud Storage, puedes obtener el ID del usuario único que accedió a partir de la variable
authy usarlo para controlar a qué datos podrá acceder.
Para permitir que los usuarios accedan a la app con varios proveedores de autenticación, puedes vincular las credenciales de estos proveedores con una cuenta de usuario existente.
Para salir de la sesión de un usuario, llama a signOut de la siguiente manera:
Kotlin+KTX
Firebase.auth.signOut()
Java
FirebaseAuth.getInstance().signOut();