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

Você pode usar o Firebase Authentication para fazer login de um usuário enviando uma mensagem SMS para o telefone do usuário. O usuário faz login usando um código único contido na mensagem SMS.

A maneira mais fácil de adicionar login por número de telefone ao seu aplicativo é usar FirebaseUI , que inclui um widget de login drop-in que implementa fluxos de login para login por número de telefone, bem como login federado e baseado em senha -em. Este documento descreve como implementar um fluxo de login por número de telefone usando o SDK do Firebase.

Antes de você começar

  1. Adicione o Firebase ao seu projeto Android , caso ainda não o tenha feito.
  2. No arquivo Gradle do módulo (nível do aplicativo) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle ), adicione a dependência para o Firebase Authentication biblioteca para Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versão da biblioteca.
    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.7.3"))
    
        // 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")
    }
    

    Ao usar o Firebase Android BoM , seu aplicativo sempre usará versões compatíveis das bibliotecas do Firebase Android.

    (Alternativa) Adicionar dependências da biblioteca Firebase sem usar o BoM

    Se você optar por não usar o Firebase BoM, deverá especificar cada versão da biblioteca do Firebase em sua linha de dependência.

    Observe que se você usa várias bibliotecas do Firebase no seu aplicativo, é altamente recomendável usar a BoM para gerenciar as versões da biblioteca, o que garante que todas as versões sejam compatíveis.

    dependencies {
        // Add the dependency for the Firebase Authentication library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-auth:22.3.1")
    }
    
    Procurando um módulo de biblioteca específico para Kotlin? A partir de outubro de 2023 (Firebase BoM 32.5.0) , tanto os desenvolvedores Kotlin quanto os Java podem depender do módulo da biblioteca principal (para obter detalhes, consulte o FAQ sobre esta iniciativa ).
  3. Se você ainda não conectou seu aplicativo ao projeto do Firebase, faça isso no console do Firebase .
  4. Se você ainda não definiu o hash SHA-1 do seu aplicativo no console do Firebase , faça-o. Consulte Autenticando seu cliente para obter informações sobre como encontrar o hash SHA-1 do seu aplicativo.

Preocupações com segurança

A autenticação usando apenas um número de telefone, embora conveniente, é menos segura do que outros métodos disponíveis, porque a posse de um número de telefone pode ser facilmente transferida entre usuários. Além disso, em dispositivos com vários perfis de usuário, qualquer usuário que possa receber mensagens SMS poderá fazer login em uma conta usando o número de telefone do dispositivo.

Se você usar o login baseado em número de telefone em seu aplicativo, deverá oferecê-lo junto com métodos de login mais seguros e informar os usuários sobre as desvantagens de segurança do uso do login por número de telefone.

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

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

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

A cota de solicitações de login por número de telefone do Firebase é alta o suficiente para que a maioria dos aplicativos não seja afetada. No entanto, se você precisar conectar um volume muito grande de usuários com autenticação por telefone, talvez seja necessário atualizar seu plano de preços. Veja a página de preços .

Ativar verificação de aplicativos

Para usar a autenticação por número de telefone, o Firebase precisa ser capaz de verificar se as solicitações de login por número de telefone vêm do seu aplicativo. Existem três maneiras pelas quais o Firebase Authentication faz isso:

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

    Para usar o Play Integrity, se você ainda não especificou a impressão digital SHA-256 do seu aplicativo, faça-o nas configurações do projeto no console do Firebase. Consulte Autenticando seu cliente para obter detalhes sobre como obter a impressão digital SHA-256 do seu aplicativo.

  • Verificação reCAPTCHA : caso o Play Integrity não possa ser usado, 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 do telefone. O desafio do reCAPTCHA muitas vezes pode ser concluído sem que o usuário precise resolver nada. Observe que esse fluxo requer que um SHA-1 esteja associado ao seu aplicativo. Este fluxo também exige que sua chave de API seja irrestrita ou esteja na 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 aplicativo não for distribuído pela Google Play Store (no Authentication SDK v21.2.0+ ).
    • Se o token SafetyNet obtido não for válido (nas versões do Authentication SDK <v21.2.0).

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

Você pode forçar o fluxo de verificação do reCAPTCHA com forceRecaptchaFlowForTesting Você pode desativar a verificação do aplicativo (ao usar números de telefone fictícios) usando setAppVerificationDisabledForTesting .

Solução de problemas

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

    Isso pode ocorrer quando o fluxo reCAPTCHA é concluído com êxito, mas não redireciona o usuário de volta ao 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á desabilitada por padrão. Se você vir o erro acima no Firefox, siga as etapas em Configurar o Firefox para Android para abrir links em aplicativos nativos para permitir a abertura de links de aplicativos.

Envie um código de verificação para o telefone do usuário

Para iniciar o login do número de telefone, apresente ao usuário uma interface que solicita que ele digite o número de telefone. Os requisitos legais variam, mas como prática recomendada e para definir expectativas para seus usuários, você deve informá-los de que, se usarem login por telefone, poderão receber uma mensagem SMS para verificação e serão aplicadas taxas padrão.

Em seguida, passe 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)

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

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

Você pode usar esse comportamento para retomar o processo de login do número de telefone se o seu aplicativo fechar antes que o usuário possa entrar (por exemplo, enquanto o usuário estiver usando o aplicativo SMS). Depois de chamar verifyPhoneNumber , defina um sinalizador que indique que a verificação está em andamento. Em seguida, salve o sinalizador no método onSaveInstanceState da sua atividade e restaure o sinalizador em onRestoreInstanceState . Por fim, no método onStart da sua Activity, verifique se a verificação já está em andamento e, em caso afirmativo, chame verifyPhoneNumber novamente. Certifique-se de limpar o sinalizador quando a verificação for concluída ou falhar (consulte Retornos de chamada de verificação ).

Para lidar facilmente com a rotação da tela e outras instâncias de reinicializações de atividades, passe sua atividade para o método verifyPhoneNumber . Os retornos de chamada serão desanexados automaticamente quando a atividade for interrompida, para que você possa escrever livremente o código de transição da IU nos métodos de retorno de chamada.

A mensagem SMS enviada pelo Firebase também pode ser localizada especificando o idioma de autenticação por meio do método setLanguageCode em sua instância Auth.

Kotlin+KTX

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

Java

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

Ao chamar PhoneAuthProvider.verifyPhoneNumber , você também deve fornecer uma instância de OnVerificationStateChangedCallbacks , que contém implementações das funções de retorno de chamada que tratam dos 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
    }
}

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

Retornos de chamada de verificação

Na maioria dos aplicativos, você implementa os retornos de chamada onVerificationCompleted , onVerificationFailed e onCodeSent . Você também pode implementar onCodeAutoRetrievalTimeOut , dependendo dos requisitos do seu aplicativo.

onVerificationCompleted(PhoneAuthCredential)

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

  • Verificação instantânea: em alguns casos, o número de telefone pode ser verificado instantaneamente sem a necessidade de 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 realizar a verificação sem ação do usuário. (Esse recurso pode não estar disponível em 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 você pode usar o objeto PhoneAuthCredential que é passado ao retorno de chamada para fazer login no usuário .

onVerificationFailed(FirebaseException)

Este 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 código de verificação inválido.

onCodeSent (string de verificaçãoId, PhoneAuthProvider.ForceResendingToken)

Opcional. Este método é chamado após o código de verificação ser enviado por SMS para o número de telefone fornecido.

Quando esse método é chamado, a maioria dos aplicativos exibe uma IU que solicita que o usuário digite o código de verificação da mensagem SMS. (Ao mesmo tempo, a verificação automática pode ocorrer em segundo plano.) Depois que o usuário digitar o código de verificação, você poderá usar o código de verificação e o ID de verificação que foi passado ao método para criar um objeto PhoneAuthCredential , que você pode, por sua vez, usar para fazer login do usuário. No entanto, alguns aplicativos podem esperar até que onCodeAutoRetrievalTimeOut seja chamado antes de exibir a IU do código de verificação (não recomendado).

onCodeAutoRetrievalTimeOut (ID de verificação de string)

Opcional. Este método é chamado depois que o tempo limite especificado para verifyPhoneNumber tiver passado sem que onVerificationCompleted seja acionado primeiro. Em dispositivos sem cartões SIM, esse método é chamado imediatamente porque a recuperação automática de SMS não é possível.

Alguns aplicativos bloqueiam a entrada do usuário até que o período de verificação automática expire e só então exibem uma IU que solicita que o usuário digite o código de verificação da mensagem SMS (não recomendado).

Crie um objeto PhoneAuthCredential

Depois que o usuário inserir o código de verificação que o Firebase enviou ao telefone do usuário, crie um objeto PhoneAuthCredential usando o código de verificação e o ID de verificação que foi passado para o retorno de chamada onCodeSent ou onCodeAutoRetrievalTimeOut . (Quando onVerificationCompleted é chamado, você obtém um objeto PhoneAuthCredential diretamente, portanto pode pular esta etapa.)

Para criar o objeto PhoneAuthCredential , chame PhoneAuthProvider.getCredential :

Kotlin+KTX

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

Java

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

Faça login no usuário

Depois de obter um objeto PhoneAuthCredential , seja no retorno de chamada onVerificationCompleted ou chamando PhoneAuthProvider.getCredential , conclua o fluxo de login passando 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
            }
        }
}

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

Teste com números de telefone fictícios

Você pode configurar números de telefone fictícios para desenvolvimento por meio do Console do Firebase. Testar com números de telefone fictícios oferece estes benefícios:

  • Teste a autenticação do número de telefone sem consumir sua cota de uso.
  • Teste a autenticação do número de telefone sem enviar uma mensagem SMS real.
  • Execute testes consecutivos com o mesmo número de telefone sem ser limitado. Isso minimiza o risco de rejeição durante o processo de revisão da App Store se o revisor usar o mesmo número de telefone para o teste.
  • Teste prontamente em ambientes de desenvolvimento sem nenhum esforço adicional, como a capacidade de desenvolver em um simulador iOS ou em um emulador Android sem o Google Play Services.
  • Escreva testes de integração sem ser bloqueado por verificações de segurança normalmente aplicadas em números de telefone reais em um ambiente de produção.

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

  1. Certifique-se de usar números de telefone que sejam realmente fictícios e que ainda não existam. O Firebase Authentication não permite definir números de telefone existentes usados ​​por usuários reais como números de teste. Uma opção é usar números prefixados 555 como números de telefone de teste nos EUA, por exemplo: +1 650-555-3434
  2. Os números de telefone devem ser formatados corretamente quanto ao comprimento e outras restrições. Eles ainda passarão pela mesma validação que o número de telefone de um usuário real.
  3. Você pode adicionar até 10 números de telefone para desenvolvimento.
  4. Use números/códigos de telefone de teste que sejam difíceis de adivinhar e altere-os com frequência.

Crie 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 , habilite a operadora de telefonia, caso ainda não o tenha feito.
  3. Abra o menu acordeão Números de telefone para teste .
  4. Forneça o número de telefone que deseja testar, por exemplo: +1 650-555-3434 .
  5. Forneça o código de verificação de 6 dígitos para esse número específico, por exemplo: 654321 .
  6. Adicione o número. Se houver necessidade, você pode excluir o número de telefone e seu código passando o mouse sobre a linha correspondente e clicando no ícone da lixeira.

Teste manual

Você pode começar a usar diretamente um número de telefone fictício em seu aplicativo. Isso permite que você execute testes manuais durante os estágios de desenvolvimento sem enfrentar problemas de cota ou limitação. Você também pode testar diretamente de um simulador iOS ou emulador Android sem o Google Play Services instalado.

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, você precisa fornecer o código de verificação configurado anteriormente para concluir o login.

Após a conclusão do login, um usuário do Firebase é criado com esse número de telefone. O usuário tem o mesmo comportamento e propriedades de um usuário de número de telefone real e pode acessar o Realtime Database/Cloud Firestore e outros serviços da mesma maneira. O token de identificação gerado durante esse processo tem a mesma assinatura de um usuário de número de telefone real.

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

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

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

Teste de integração

Além dos testes manuais, o Firebase Authentication fornece APIs para ajudar a escrever testes de integração para testes de autenticação por telefone. Essas APIs desativam a verificação de aplicativos, desativando o requisito reCAPTCHA na web e notificações push silenciosas no iOS. Isso torna os testes de automação possíveis nesses fluxos e mais fáceis de implementar. Além disso, eles ajudam a fornecer a capacidade de testar fluxos de verificação instantâneos no Android.

No Android, chame setAppVerificationDisabledForTesting() antes da chamada signInWithPhoneNumber . Isso desativa a verificação do aplicativo automaticamente, permitindo que você passe o número de telefone sem resolvê-lo manualmente. Mesmo que o Play Integrity e o reCAPTCHA estejam desativados, o uso de um número de telefone real ainda não conseguirá concluir o login. Somente números de telefone fictícios podem ser usados ​​com esta API.

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

Chamar verifyPhoneNumber com um número fictício aciona o retorno de chamada onCodeSent , no qual você precisará fornecer o código de verificação correspondente. Isso permite testes em emuladores Android.

Java

String phoneNum = "+16505554567";
String testVerificationCode = "123456";

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
FirebaseAuth auth = FirebaseAuth.getInstance();
PhoneAuthOptions options = PhoneAuthOptions.newBuilder(auth)
        .setPhoneNumber(phoneNum)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onCodeSent(@NonNull String verificationId,
                                   @NonNull PhoneAuthProvider.ForceResendingToken forceResendingToken) {
                // Save the verification id somewhere
                // ...

                // The corresponding whitelisted code above should be used to complete sign-in.
                MainActivity.this.enableUserManuallyInputCode();
            }

            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential phoneAuthCredential) {
                // Sign in with the credential
                // ...
            }

            @Override
            public void onVerificationFailed(@NonNull FirebaseException e) {
                // ...
            }
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);

Kotlin+KTX

val phoneNum = "+16505554567"
val testVerificationCode = "123456"

// Whenever verification is triggered with the whitelisted number,
// provided it is not set for auto-retrieval, onCodeSent will be triggered.
val options = PhoneAuthOptions.newBuilder(Firebase.auth)
    .setPhoneNumber(phoneNum)
    .setTimeout(30L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {

        override fun onCodeSent(
            verificationId: String,
            forceResendingToken: PhoneAuthProvider.ForceResendingToken,
        ) {
            // Save the verification id somewhere
            // ...

            // The corresponding whitelisted code above should be used to complete sign-in.
            this@MainActivity.enableUserManuallyInputCode()
        }

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

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

Além disso, você pode testar fluxos de recuperação automática no Android definindo o número fictício e seu código de verificação correspondente para recuperação automática chamando setAutoRetrievedSmsCodeForPhoneNumber .

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

Certifique-se de que isso esteja desativado e que nenhum número de telefone fictício esteja codificado em seu aplicativo ao publicá-lo na Google Play Store.

Java

// The test phone number and code should be whitelisted in the console.
String phoneNumber = "+16505554567";
String smsCode = "123456";

FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
FirebaseAuthSettings firebaseAuthSettings = firebaseAuth.getFirebaseAuthSettings();

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode);

PhoneAuthOptions options = PhoneAuthOptions.newBuilder(firebaseAuth)
        .setPhoneNumber(phoneNumber)
        .setTimeout(60L, TimeUnit.SECONDS)
        .setActivity(this)
        .setCallbacks(new PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
            @Override
            public void onVerificationCompleted(@NonNull PhoneAuthCredential credential) {
                // Instant verification is applied and a credential is directly returned.
                // ...
            }

            // ...
        })
        .build();
PhoneAuthProvider.verifyPhoneNumber(options);

Kotlin+KTX

// The test phone number and code should be whitelisted in the console.
val phoneNumber = "+16505554567"
val smsCode = "123456"

val firebaseAuth = Firebase.auth
val firebaseAuthSettings = firebaseAuth.firebaseAuthSettings

// Configure faking the auto-retrieval with the whitelisted numbers.
firebaseAuthSettings.setAutoRetrievedSmsCodeForPhoneNumber(phoneNumber, smsCode)

val options = PhoneAuthOptions.newBuilder(firebaseAuth)
    .setPhoneNumber(phoneNumber)
    .setTimeout(60L, TimeUnit.SECONDS)
    .setActivity(this)
    .setCallbacks(object : PhoneAuthProvider.OnVerificationStateChangedCallbacks() {
        override fun onVerificationCompleted(credential: PhoneAuthCredential) {
            // Instant verification is applied and a credential is directly returned.
            // ...
        }

        // ...
    })
    .build()
PhoneAuthProvider.verifyPhoneNumber(options)

Próximos passos

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais (ou seja, nome de usuário e senha, número de telefone ou informações do provedor de autenticação) com as quais o usuário fez login. Essa nova conta é armazenada como parte do seu projeto do Firebase e pode ser usada para identificar um usuário em todos os aplicativos do seu projeto, independentemente de como o usuário faz login.

  • Nos seus aplicativos, você pode obter informações básicas do perfil do usuário no objeto FirebaseUser . Consulte Gerenciar usuários .

  • Nas regras de segurança do Firebase Realtime Database e do Cloud Storage , você pode obter o ID de usuário exclusivo do usuário conectado na variável auth e usá-lo para controlar quais dados um usuário pode acessar.

Você pode permitir que os usuários façam login no seu aplicativo usando vários provedores de autenticação vinculando as credenciais do provedor de autenticação a uma conta de usuário existente.

Para desconectar um usuário, chame signOut :

Kotlin+KTX

Firebase.auth.signOut()

Java

FirebaseAuth.getInstance().signOut();