Autentica con Firebase en Android mediante un número de teléfono

Puedes usar Firebase Authentication para enviar un mensaje SMS al teléfono de un usuario para que este acceda. 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.

Los números de teléfono que proporcionen los usuarios finales para la autenticación se enviarán a Google y se almacenarán para mejorar la prevención del abuso y el spam en los servicios de Google, incluido Firebase. Los desarrolladores deben asegurarse de contar con el consentimiento correspondiente del usuario final antes de usar el servicio de acceso con número de teléfono de Firebase Authentication.

Antes de comenzar

1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android.
2. En el archivo Gradle del módulo (nivel de la app) (generalmente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), agrega la dependencia de la biblioteca de Firebase Authentication para Android. Te recomendamos usar Firebase Android BoM para controlar las versiones de las bibliotecas.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.6.0"))
   
       // 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")
   }

   Cuando usas Firebase Android BoM, tu app siempre usará 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 Firebase BoM, 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 uses 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:23.1.0")
   }

   ¿Buscas un módulo de biblioteca específico de Kotlin? A partir de octubre de 2023 (Firebase BoM 32.5.0), tanto los desarrolladores de Kotlin como los de Java pueden depender del módulo de la biblioteca principal (para obtener más información, consulta la Preguntas frecuentes sobre esta iniciativa).
3. Si aún no has conectado la app al proyecto de Firebase, puedes hacerlo desde la consola de Firebase
4. 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:

1. En Firebase console, abre la sección Authentication.
2. En la página de método de acceso, habilita el método de acceso Número de teléfono.

Cuando habilitas la autenticación con número de teléfono en Android, aceptas los Términos y Condiciones de Play Integrity.

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 lo hace de tres maneras:

• API de Play Integrity: Si un usuario tiene un dispositivo con Google Play services instalado y Firebase Authentication puede verificarlo como legítimo con la API de Play Integrity, el acceso con número de teléfono puede continuar. La API de Play Integrity está habilitada en un proyecto de Google de Firebase Authentication, no en tu proyecto. Esto no contribuye a ninguna cuota de la API de Play Integrity en tu proyecto. La compatibilidad con 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 Firebase BoM).

  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 instalado Google Play services), Firebase Authentication usa una verificación de reCAPTCHA para completar el flujo de 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 instalado Google Play services.
  • Si la app no se distribuye a través de Google Play Store (en el SDK de Authentication versión 21.2.0 o 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, el campo %APP_NAME% de la plantilla de SMS se propaga con el nombre de la app determinado a partir de Google Play Store. En los casos en que se activa reCAPTCHA, %APP_NAME% se propaga como PROJECT_ID.firebaseapp.com.

  Las versiones del SDK de Authentication anteriores a la 22.0.0 usan SafetyNet como resguardo si falla la recuperación de tokens de Play Integrity. Solo se activará el flujo de reCAPTCHA cuando Play Integrity o SafetyNet no estén disponibles. No obstante, debes asegurarte de que ambas situaciones funcionen correctamente.
  Comienza en el SDK de Authentication v21.2.0 (Firebase BoM v31.4.0), el parámetro de actividad es opcional. Sin embargo, si no se establece la actividad y se intenta la verificación de reCAPTCHA, se genera una FirebaseAuthMissingActivityForRecaptchaException, que puede administrarse en la devolución de llamada de onVerificationFailed.

Puedes forzar el flujo de verificación de reCAPTCHA con 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)
PhoneAuthActivity.kt

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);     
PhoneAuthActivity.java

Nota: Consulta Límites de Firebase Authentication para conocer los límites de uso y las cuotas aplicables.

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()
MainActivity.kt

Java

auth.setLanguageCode("fr");
// To apply the default app language instead of explicitly setting it.
// auth.useAppLanguage();
MainActivity.java

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
    }
}
PhoneAuthActivity.kt

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;
    }
};
PhoneAuthActivity.java

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.

En ambos casos, el número de teléfono del usuario se verificó correctamente, por lo que se puede usar el objeto 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)
PhoneAuthActivity.kt

Java

PhoneAuthCredential credential = PhoneAuthProvider.getCredential(verificationId, code);
PhoneAuthActivity.java

Para evitar abusos, Firebase aplica un límite a la cantidad de SMS que se puede enviar al mismo número de teléfono en un período. Si superas este límite, es posible que se limiten las solicitudes de verificación del número de teléfono. Si te encuentras con este problema durante el desarrollo de tu app, usa otro número de teléfono para hacer pruebas o vuelve a realizar la solicitud más tarde.

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
            }
        }
}
PhoneAuthActivity.kt

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
                        }
                    }
                }
            });
}
PhoneAuthActivity.java

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:

1. Asegúrate de usar números de teléfono que sean ficticios y que aún no existan. Firebase Authentication no te 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.
2. 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.
3. Puedes agregar hasta 10 números de teléfono.
4. 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

1. En la consola de Firebase, abre la sección Authentication.
2. En la pestaña Método de acceso, habilita el proveedor de telefonía, si todavía no lo has hecho.
3. Abre el menú de acordeón Números de teléfono para la prueba.
4. Proporciona el número de teléfono que deseas probar, por ejemplo: [phone].
5. Proporciona el código de verificación de 6 dígitos para ese número específico, por ejemplo: 654321.
6. 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.

Como el token de ID para el número de teléfono ficticio tiene la misma firma que el usuario de un número de teléfono real, es importante almacenar estos números de forma segura y reciclarlos continuamente.

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();

Pruebas de integración

Además de las pruebas manuales, Firebase Authentication proporciona APIs para ayudar a escribir pruebas de integración para las pruebas de autenticación telefónica. 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.

Asegúrate de que la verificación de apps no esté inhabilitada para las apps de producción y que los números de teléfono ficticios no estén codificados en tu app de producción.

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 = "[phone]";
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);
MainActivity.java

Kotlin+KTX

val phoneNum = "[phone]"
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.
            [e-mail]ode()
        }

        override fun onVerificationCompleted(phoneAuthCredential: PhoneAuthCredential) {
            // Sign in with the credential
            // ...
        }

        override fun onVerificationFailed(e: FirebaseException) {
            // ...
        }
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)
MainActivity.kt

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 = "[phone]";
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);
MainActivity.java

Kotlin+KTX

// The test phone number and code should be whitelisted in the console.
val phoneNumber = "[phone]"
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)
MainActivity.kt

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 auth y usarlo para controlar a qué datos podrá acceder.

Para permitir que los usuarios accedan a tu app mediante 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()
MainActivity.kt

Java

FirebaseAuth.getInstance().signOut();
MainActivity.java