Autenticar com o Firebase no Android usando um número de telefone

Use Firebase Authentication para fazer o login de um usuário. Basta enviar uma mensagem SMS para o smartphone dele. O usuário faz login com um código de uso único contido na mensagem SMS.

A maneira mais fácil de adicionar o login com número de telefone ao app é usar a FirebaseUI. Ela inclui um widget drop-in que implementa fluxos para logins com número de telefone, bem como logins por senha ou federados. Este documento descreve como implementar um fluxo de login com número de telefone pelo SDK do Firebase.

Os números de telefone que os usuários finais fornecem para autenticação são enviados e armazenados pelo Google para melhorar a prevenção de spam e abusos em nossos serviços, incluindo o Firebase, mas não se limitando a ele. Os desenvolvedores devem garantir que tenham o consentimento do usuário final antes de usar o serviço de login com número de telefone do Firebase Authentication.

Antes de começar

1. Adicione o Firebase ao seu projeto para Android, caso ainda não tenha feito isso.
2. No arquivo Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), adicione a dependência da biblioteca do Firebase Authentication para Android. Recomendamos o uso do Firebase Android BoM para lidar com o controle de versões da biblioteca.

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

   Com o Firebase Android BoM, seu app sempre vai usar versões compatíveis das bibliotecas do Firebase para Android.

   (Alternativa) Adicionar dependências das bibliotecas do Firebase sem usar o BoM

   Se você preferir não usar o Firebase BoM, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

   Se você usa várias bibliotecas do Firebase no app, recomendamos utilizar o BoM para gerenciar as versões delas, porque isso ajuda a garantir a compatibilidade de todas as bibliotecas.

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

   Está procurando um módulo de biblioteca específico do Kotlin? A partir de outubro de 2023 (Firebase BoM 32.5.0), os desenvolvedores de Kotlin e Java poderão contar com o módulo da biblioteca principal. Para mais detalhes, consulte Perguntas frequentes sobre essa iniciativa.
3. Caso você ainda não tenha vinculado o app ao projeto do Firebase, faça isso no console do Firebase.
4. Caso ainda não tenha definido o hash SHA-1 do app no console do Firebase, faça isso. Consulte Como autenticar seu cliente para saber como encontrar o hash SHA-1 do app.

Preocupações com segurança

A autenticação usando apenas um número de telefone é conveniente, porém, menos segura do que os outros métodos disponíveis, já que um número de telefone pode ser facilmente transferido entre usuários. Além disso, em dispositivos com vários perfis de usuário, qualquer um que receba mensagens SMS pode fazer login em uma conta usando o número de telefone do dispositivo.

Caso use o login com número de telefone no seu app, você precisa oferecê-lo junto com métodos de login mais seguros e informar aos usuários as implicações de segurança do uso desse tipo de login.

Ativar o login com número de telefone para o projeto do Firebase

Para fazer login de usuários por SMS, ative primeiro o método de login por número de telefone para o projeto do Firebase:

1. No console do Firebase, abra a seção Autenticação.
2. Na página Método de login, ative o método de login por Número de telefone.

Ao ativar a autenticação por número de telefone no Android, você concorda com os Termos e Condições da Play Integrity.

Ativar a verificação do aplicativo

Para usar a autenticação por número de telefone, o Firebase precisa verificar se as solicitações de login do número de telefone estão vindo do seu app. O Firebase Authentication faz isso de três formas:

• API Play Integrity: se um usuário tiver um dispositivo com o Google Play services instalado e o Firebase Authentication conseguir confirmar que o dispositivo é legítimo com a API Play Integrity, o login com número de telefone poderá continuar. Essa API é ativada pelo Firebase Authentication em um projeto do Google, não no seu. Isso não contribui para nenhuma cota da API Play Integrity no seu projeto. O suporte da Play Integrity está disponível com o SDK do Authentication v21.2.0+ (Firebase BoM v31.4.0+).

  Para usar a Play Integrity, especifique a impressão digital SHA-256 do app nas Configurações do projeto no console do Firebase. Consulte Como autenticar seu cliente para mais detalhes sobre como conseguir a impressão digital SHA-1 do app.

• Verificação reCAPTCHA: quando não é possível usar a Play Integrity, como quando um usuário tem um dispositivo sem o Google Play services instalado, o Firebase Authentication usa uma verificação reCAPTCHA para concluir o fluxo de login por telefone. O teste reCAPTCHA pode ser concluído sem que o usuário tenha que resolver nada. Esse fluxo requer que um SHA-1 esteja associado ao seu aplicativo. Esse fluxo também exige que sua chave de API não tenha restrições ou seja adicionada à lista de permissões para PROJECT_ID.firebaseapp.com.

  Alguns cenários em que o reCAPTCHA é acionado:

  • Se o dispositivo do usuário final não tiver o Google Play services instalado.
  • Se o app não for distribuído pelo Google Play Store (no SDK do Authentication v21.2.0+).
  • Se o token SafetyNet recebido não for válido (em versões do SDK do Authentication anteriores à v21.2.0).

  Quando o SafetyNet ou a Play Integrity são usados para a verificação de apps, o campo %APP_NAME% no modelo de SMS é preenchido com o nome do app determinado por Google Play Store. Nos cenários em que o reCAPTCHA é acionado, %APP_NAME% é preenchido como PROJECT_ID.firebaseapp.com.

  As versões do SDK do Authentication anteriores à 22.0.0 usam o SafetyNet como substituto quando a busca do token da Play Integrity falha. O fluxo reCAPTCHA só será acionado quando a Play Integrity ou o SafetyNet não estiverem disponíveis. No entanto, você precisa garantir que os dois cenários estejam funcionando corretamente.
  A partir do SDK do Authentication v21.2.0 (Firebase BoM v31.4.0), o parâmetro de atividade é opcional. No entanto, se a atividade não estiver definida e a verificação reCAPTCHA for feita, um FirebaseAuthMissingActivityForRecaptchaException será gerado, e isso pode ser processado no callback onVerificationFailed.

É possível forçar o fluxo de verificação reCAPTCHA com forceRecaptchaFlowForTesting. Se quiser desativar a verificação de apps (ao usar números de telefone fictícios) use setAppVerificationDisabledForTesting.

Solução de problemas

• Erro "Estado inicial ausente" ao usar reCAPTCHA para verificação de app

  Isso pode ocorrer quando o fluxo reCAPTCHA é concluído, mas não redireciona o usuário de volta para o aplicativo nativo. Se isso ocorrer, o usuário será redirecionado para o URL substituto PROJECT_ID.firebaseapp.com/__/auth/handler. Nos navegadores Firefox, a abertura de links de aplicativos nativos está desativada por padrão. Se você vir o erro acima no Firefox, siga as etapas em Configurar o Firefox para Android para abrir links em apps nativos para ativar a abertura de links de apps.

Enviar um código de verificação ao telefone do usuário

Para iniciar o login com número de telefone, mostre ao usuário uma interface em que ele precisará inserir o número. Os requisitos legais variam, mas, como prática recomendada e para definir as expectativas dos usuários, informe que, ao fazer login com telefone, eles podem receber uma mensagem SMS para verificação e uma cobrança pelo serviço.

Em seguida, transmita o número de telefone para o método PhoneAuthProvider.verifyPhoneNumber para solicitar que o Firebase verifique o número de telefone do usuário. Por exemplo:

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

Observação: consulte Limites do Firebase Authentication para conferir os limites e as cotas de uso aplicáveis.

O método verifyPhoneNumber é reentrante: se você chamá-lo várias vezes, como no método onStart de uma atividade, o método verifyPhoneNumber não enviará um segundo SMS, a menos que a solicitação original tenha atingido o tempo limite.

Você pode usar esse comportamento para retomar o processo de login com número de telefone caso o app seja fechado antes de o usuário fazer login. Por exemplo, enquanto o usuário usa o app de SMS. Depois de chamar verifyPhoneNumber, defina uma sinalização que indique que a verificação está em andamento. Em seguida, salve a sinalização no método onSaveInstanceState da sua atividade e restaure a sinalização em onRestoreInstanceState. Por fim, no método onStart da atividade, veja se a verificação já está em andamento e, em caso afirmativo, chame verifyPhoneNumber novamente. Não esqueça de limpar a sinalização depois da conclusão ou falha da verificação. Consulte Callbacks de verificação.

Para gerenciar facilmente a rotação da tela e outras instâncias de reinicializações da atividade, transmita a atividade ao método verifyPhoneNumber. Os callbacks serão desconectados automaticamente quando a atividade for interrompida. Assim, você pode escrever o código de transição da IU livremente nos métodos de callback.

A mensagem SMS enviada pelo Firebase também pode ser localizada especificando o idioma de autenticação pelo método setLanguageCode na instância do 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

Ao chamar PhoneAuthProvider.verifyPhoneNumber, você também precisa fornecer uma instância de OnVerificationStateChangedCallbacks, que contém implementações das funções de callback que gerenciam os resultados da solicitação. Por exemplo:

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

Callbacks de verificação

Na maioria dos apps, os callbacks onVerificationCompleted, onVerificationFailed e onCodeSent são implementados. Você também pode implementar onCodeAutoRetrievalTimeOut, dependendo dos requisitos de seu app.

onVerificationCompleted(PhoneAuthCredential)

Esse método é chamado em duas situações:

• Verificação instantânea: em alguns casos, o número de telefone pode ser verificado instantaneamente sem que você precise enviar ou inserir um código de verificação.
• Recuperação automática: em alguns dispositivos, o Google Play Services pode detectar automaticamente o SMS de verificação recebido e executar a verificação sem que nenhuma ação do usuário seja necessária. Esse recurso pode não estar disponível para algumas operadoras. Isso usa a API SMS Retriever, que inclui um hash de 11 caracteres no final da mensagem SMS.

Em ambos os casos, o número de telefone do usuário foi verificado com êxito e é possível usar o objeto PhoneAuthCredential que é transmitido ao callback para fazer login do usuário.

onVerificationFailed(FirebaseException)

Esse método é chamado em resposta a uma solicitação de verificação inválida, como uma solicitação que especifica um número de telefone ou um código de verificação inválido.

onCodeSent(String verificationId, PhoneAuthProvider.ForceResendingToken)

Opcional. Esse método é chamado depois que o código de verificação é enviado por SMS ao número de telefone fornecido.

Quando esse método é chamado, a maioria dos apps exibe uma IU que solicita que o usuário digite o código de verificação incluso na mensagem SMS. Ao mesmo tempo, a verificação automática pode estar em segundo plano. Em seguida, depois que o usuário digitar o código, é possível usar esse código e o ID da verificação que foram transmitidos ao método para criar um objeto PhoneAuthCredential, que pode ser usado para fazer o login do usuário. No entanto, alguns apps podem esperar até que onCodeAutoRetrievalTimeOut seja chamado antes de exibir a IU do código de verificação (não recomendado).

onCodeAutoRetrievalTimeOut(String verificationId)

Opcional. Este método é chamado depois que o tempo limite especificado para verifyPhoneNumber tiver decorrido sem onVerificationCompleted ser acionado primeiro. Em dispositivos sem chip, esse método é chamado imediatamente porque não é possível recuperar o SMS automaticamente.

Alguns apps bloqueiam a entrada do usuário até que o tempo limite da verificação automática se esgote. Depois disso, eles exibem uma IU que solicita a inserção do código de verificação recebido pelo usuário via mensagem SMS (não recomendado).

Criar um objeto PhoneAuthCredential

Depois que o usuário digitar o código de verificação enviado pelo Firebase, crie um objeto PhoneAuthCredential usando esse código e a identificação da verificação que foram transmitidos ao callback onCodeSent ou onCodeAutoRetrievalTimeOut. Quando onVerificationCompleted for chamado, você receberá um objeto PhoneAuthCredential diretamente, portanto, poderá ignorar esta etapa.

Para criar o objeto PhoneAuthCredential, chame PhoneAuthProvider.getCredential:

Kotlin+KTX

val credential = PhoneAuthProvider.getCredential(verificationId!!, code)
PhoneAuthActivity.kt

Java

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

Para prevenir abusos, o Firebase impõe um limite no número de mensagens SMS que podem ser enviadas a um único número de telefone dentro de um período. Se esse limite for ultrapassado, as solicitações de verificação do número de telefone poderão ser restringidas. Se você encontrar este problema durante o desenvolvimento, use um número de telefone diferente para testar ou tente fazer a solicitação novamente mais tarde.

Fazer o login do usuário

Depois de receber um objeto PhoneAuthCredential, seja no callback onVerificationCompleted ou ao chamar PhoneAuthProvider.getCredential, conclua o fluxo de login transmitindo o objeto PhoneAuthCredential para FirebaseAuth.signInWithCredential:

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

Testar com números de telefone fictícios

É possível configurar números de telefone fictícios para desenvolvimento no console do Firebase. Com isso, você tem estes benefícios:

• A autenticação do número de telefone é feita sem consumir sua cota de uso.
• A autenticação do número de telefone é feita sem enviar uma mensagem SMS real.
• Testes consecutivos são executados com o mesmo número de telefone, sem que haja limitação. Isso minimiza o risco de rejeição durante o processo de revisão da App store, caso o revisor use o mesmo número de telefone para teste.
• O teste em ambientes de desenvolvimento é feito prontamente e sem esforço extra, como a capacidade de desenvolver um simulador do iOS ou um emulador do Android sem o Google Play Services.
• A criação de testes de integração é feita sem que haja bloqueio por verificações de segurança, que normalmente são aplicadas a números de telefone reais em um ambiente de produção.

Os números de telefone fictícios precisam atender a estes requisitos:

1. Use números de telefone que sejam realmente fictícios e não existam. No Firebase Authentication, não é possível definir números de telefone atuais usados por usuários reais como números de teste. Uma opção é usar números com prefixo 555 como números de telefone de teste dos EUA, por exemplo: [phone]
2. Os números de telefone precisam estar formatados corretamente para atender a restrições como o tamanho. Eles ainda passarão pela mesma validação dos números de usuários reais.
3. Você pode adicionar até 10 números de telefone para desenvolvimento.
4. Use números de telefone/códigos de teste difíceis de adivinhar e altere-os com frequência.

Criar números de telefone e códigos de verificação fictícios

1. No console do Firebase, abra a seção Autenticação.
2. Na guia Método de login, ative o provedor de telefonia, se ainda não fez isso.
3. Abra o menu suspenso Números de telefone para testes.
4. Informe o número de telefone que você quer testar, por exemplo: [phone].
5. Informe o código de verificação de seis dígitos para esse número específico, por exemplo: 654321.
6. Adicione o número. Se precisar, exclua o número de telefone e o código. Basta passar o cursor sobre a linha correspondente e clicar no ícone da lixeira.

Teste manual

Você pode começar a usar um número de telefone fictício diretamente no seu aplicativo. Dessa maneira, você pode executar testes manuais durante as etapas de desenvolvimento sem problemas de cotas ou limitações. Também é possível testar diretamente, a partir de um simulador do iOS ou emulador do Android, sem a instalação do Google Play Services.

Quando você fornece o número de telefone fictício e envia o código de verificação, nenhum SMS real é enviado. Em vez disso, é necessário informar o código de verificação configurado anteriormente para concluir o login.

Quando o login é concluído, um usuário do Firebase é criado com aquele número de telefone. O usuário tem o mesmo comportamento e as mesmas propriedades de um usuário com um número de telefone real e pode acessar Realtime Database/Cloud Firestore e outros serviços da mesma forma. O token de ID gerado durante esse processo tem a mesma assinatura de um usuário com um número de telefone real.

Como o token de ID do número de telefone fictício tem a mesma assinatura de um usuário com um número de telefone real, é importante armazenar esses números com segurança e trocá-los continuamente.

Outra opção é definir um papel de teste por meio de declarações personalizadas nesses usuários para diferenciá-los como usuários falsos, se você quiser restringir ainda mais o acesso.

Para acionar manualmente o fluxo reCAPTCHA para testes, use o método forceRecaptchaFlowForTesting().

// Force reCAPTCHA flow
FirebaseAuth.getInstance().getFirebaseAuthSettings().forceRecaptchaFlowForTesting();

Teste de integração

Além do teste manual, o Firebase Authentication oferece APIs para ajudar na criação de testes de integração para a autenticação por telefone. Essas APIs desativam a verificação de apps removendo o requisito reCAPTCHA na Web e em notificações push silenciosas no iOS. Isso possibilita o teste de automação nesses fluxos e facilita a implementação. Além disso, fica mais fácil testar os fluxos de verificação instantânea no Android.

Certifique-se de que a validação esteja ativada para aplicativos de produção e de que nenhum número de telefone fictício esteja codificado no aplicativo de produção.

No Android, chame setAppVerificationDisabledForTesting() antes de chamar signInWithPhoneNumber. Isso desativa a verificação de apps automaticamente e permite que você passe o número de telefone sem resolvê-lo manualmente. Mesmo que a Play Integrity e o reCAPTCHA estejam desativados, ainda não vai ser possível fazer login usando um número de telefone real. Só é possível usar números de telefone fictícios com essa API.

// Turn off phone auth app verification.
FirebaseAuth.getInstance().getFirebaseAuthSettings()
   .setAppVerificationDisabledForTesting();

Chamar verifyPhoneNumber com um número fictício aciona o callback onCodeSent, em que você precisa indicar o código de verificação correspondente. Isso permite testar em emuladores do 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

Além disso, é possível testar os fluxos de extração automática no Android ao definir o número fictício e seu código de verificação correspondente para a extração automática ao chamar setAutoRetrievedSmsCodeForPhoneNumber.

Quando verifyPhoneNumber é chamado, ele aciona onVerificationCompleted com PhoneAuthCredential diretamente. Isso funciona apenas com números de telefone fictícios.

Verifique se ele está desativado e se nenhum número de telefone fictício está codificado ao publicar seu aplicativo na 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óximas etapas

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais, que podem ser o número do telefone, o nome de usuário e a senha ou as informações do provedor de autenticação. Essa nova conta é armazenada como parte do projeto do Firebase e pode ser usada para identificar um usuário em todos os apps do projeto, seja qual for o método de login utilizado.

• Você pode receber as informações básicas de perfil do usuário do objeto FirebaseUser nos seus aplicativos. Consulte Gerenciar usuários.

• Nas Regras de segurança Firebase Realtime Database e Cloud Storage, você pode acessar o ID exclusivo do usuário conectado pela variável auth e usar essas informações para controlar quais dados um usuário pode acessar.

Os usuários podem fazer login no app usando vários provedores de autenticação. Basta vincular as credenciais desses provedores a uma conta de usuário.

Para desconectar um usuário, chame signOut:

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt

Java

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