Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

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

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 uso del SDK de Firebase.

Antes de comenzar

  1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android.
  2. Usa la BoM de Firebase para Android a fin de declarar la dependencia de la biblioteca de Android para Firebase Authentication en el archivo Gradle (generalmente app/build.gradle) de tu módulo (nivel de app).

    Java

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

    Como alternativa, puedes declarar las 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 varias bibliotecas de Firebase en tu app, te recomendamos que utilices la BoM para administrar las versiones de las bibliotecas, lo que garantiza que todas las versiones sean compatibles.

    dependencies {
        // Declare 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:20.0.1'
    }
    

    Kotlin+KTX

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

    Como alternativa, puedes declarar las 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 varias bibliotecas de Firebase en tu app, te recomendamos que utilices la BoM para administrar las versiones de las bibliotecas, lo que garantiza que todas las versiones sean compatibles.

    dependencies {
        // Declare 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:20.0.1'
    }
    
  3. Si aún no conectaste la app a tu proyecto de Firebase, puedes hacerlo desde Firebase console.
  4. Si aún no configuraste el hash SHA‑1 de tu app, hazlo en Firebase console. Consulta cómo autenticar tu cliente si necesitas información para 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 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 dos maneras:

  • SafetyNet: Si un usuario cuenta con un dispositivo que tiene instalados los Servicios de Google Play y Firebase Authentication puede verificarlo como legítimo con SafetyNet de Android, el acceso con número de teléfono puede continuar.
  • Sigue estos pasos si quieres habilitar SafetyNet para usarlo con Firebase Authentication:

    1. En Google Cloud Console, habilita la API de Android DeviceCheck en tu proyecto. Se usará la clave de API de Firebase predeterminada, y se debe tener acceso a la API de DeviceCheck.
    2. Si aún no especificaste la huella digital SHA‑256 de tu app, hazlo en la página Configuración de Firebase console. Consulta cómo autenticar tu cliente si necesitas detalles para obtener la huella digital SHA‑256 de tu app.
  • Verificación con reCAPTCHA: En el caso de que no sea posible usar SafetyNet (por ejemplo, cuando el dispositivo del usuario no sea compatible con los Servicios de Google Play o cuando se pruebe tu app en un emulador), 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.

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:

Java

PhoneAuthOptions options =
  PhoneAuthOptions.newBuilder(mAuth)
      .setPhoneNumber(phoneNumber)       // Phone number to verify
      .setTimeout(60L, TimeUnit.SECONDS) // Timeout and unit
      .setActivity(this)                 // Activity (for callback binding)
      .setCallbacks(mCallbacks)          // OnVerificationStateChangedCallbacks
      .build();
  PhoneAuthProvider.verifyPhoneNumber(options);     

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)

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.

Java

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

Kotlin+KTX

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:

Java

mCallbacks = new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

    @Override
    public void onVerificationCompleted(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(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
            // ...
        }

        // 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;

        // ...
    }
};

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

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

        // ...
    }
}

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. Es posible que esta opción no esté disponible con algunos proveedores.
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:

Java

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

Kotlin+KTX

val 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:

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

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

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.
  • Ejecuta pruebas consecutivas con el mismo número de teléfono sin regulación. 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.
  • Realiza pruebas con facilidad en entornos de desarrollo sin ningún esfuerzo adicional. Por ejemplo, obtén la capacidad de desarrollar en un simulador de iOS o un emulador de Android sin los Servicios de Google Play.
  • Permite 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 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 Firebase console, 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: +1 650-555-3434.
  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 directamente en tu aplicación, lo que te permite realizar pruebas manuales durante las etapas de desarrollo sin que te encuentres con problemas de cuota o regulación. 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. Ten en cuenta que, aunque reCAPTCHA o SafetyNet estén inhabilitados, usar un número de teléfono real no completará el acceso. Solo se pueden usar números de teléfono ficticios con esta API.

// 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(String verificationId,
                                   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(PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(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(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 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 de perfil del usuario a partir del objeto FirebaseUser. Consulta Cómo administrar 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 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:

Java

FirebaseAuth.getInstance().signOut();

Kotlin+KTX

Firebase.auth.signOut()