Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

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

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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 de uso ú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 -dentro. 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. Se ainda não o fez, adicione o Firebase ao seu projeto Android .
  2. No arquivo Gradle do módulo (nível do aplicativo) (geralmente <project>/<app-module>/build.gradle ), adicione a dependência da biblioteca Android do Firebase Authentication. Recomendamos usar o Firebase Android BoM para controlar o controle de versão da biblioteca.

    Java

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

    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 do 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 em seu aplicativo, é altamente recomendável usar o 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:21.1.0'
    }
    

    Kotlin+KTX

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

    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 do 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 em seu aplicativo, é altamente recomendável usar o 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-ktx:21.1.0'
    }
    
  3. Se você ainda não conectou seu aplicativo ao projeto do Firebase, faça isso no Firebase console .
  4. Se você ainda não definiu o hash SHA-1 do seu aplicativo no console do Firebase , faça isso. Consulte Autenticação do seu cliente para obter informações sobre como localizar 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 os 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 pode 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 juntamente com métodos de login mais seguros e informar os usuários sobre as vantagens de segurança de usar o login por número de telefone.

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

Para fazer login de usuários por SMS, primeiro você deve 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 do número de telefone .

A cota de solicitação 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 fazer login em um volume muito alto de usuários com autenticação por telefone, talvez seja necessário atualizar seu plano de preços. Consulte a página de preços .

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 por número de telefone são provenientes do seu aplicativo. Há duas maneiras de o Firebase Authentication fazer isso:

  • SafetyNet : se um usuário tiver um dispositivo com o Google Play Services instalado e o Firebase Authentication puder verificar o dispositivo como legítimo com o Android SafetyNet , o login pelo número de telefone poderá prosseguir.
  • Para habilitar o SafetyNet para uso com o Firebase Authentication:

    1. No Console do Google Cloud, ative a Android DeviceCheck API para seu projeto. A chave de API padrão do Firebase será usada e precisa ter permissão para acessar a API DeviceCheck.
    2. Se você ainda não especificou a impressão digital SHA-256 do seu aplicativo, faça isso na página de configurações do console do Firebase. Consulte Autenticação do seu cliente para obter detalhes sobre como obter a impressão digital SHA-256 do seu aplicativo.
  • Verificação reCAPTCHA : caso o SafetyNet não possa ser usado, como quando o usuário não tem suporte ao Google Play Services ou ao testar seu aplicativo em um emulador, o Firebase Authentication usa uma verificação reCAPTCHA para concluir o fluxo de login por telefone. O desafio reCAPTCHA geralmente 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. Esse fluxo também exige que sua chave de API seja irrestrita ou permitida para "${PROJECT_NAME}.firebaseapp.com".

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

Para iniciar o login com número de telefone, apresente ao usuário uma interface que solicita que ele digite seu 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 o login por telefone, poderão receber uma mensagem SMS para verificação e taxas padrão aplicáveis.

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:

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)

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 seu aplicativo for fechado antes que o usuário possa entrar (por exemplo, enquanto o usuário estiver usando o aplicativo de SMS). Depois de chamar verifyPhoneNumber , defina um sinalizador que indica 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 atividade, passe sua atividade para o método verifyPhoneNumber . Os retornos de chamada serão desanexados automaticamente quando a atividade parar, para que você possa escrever livremente o código de transição da interface do usuário 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 de autenticação.

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

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:

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

Retornos 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, os serviços do Google Play podem detectar automaticamente o SMS de verificação recebido e realizar a verificação sem a 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 sucesso e você pode usar o objeto PhoneAuthCredential que é passado para o retorno de chamada para fazer login no 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 código de verificação inválido.

onCodeSent(String verificaçãoId, PhoneAuthProvider.ForceResendingToken)

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

Quando esse método é chamado, a maioria dos aplicativos exibe uma interface do usuário 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 estar ocorrendo 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 para o 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é onCodeAutoRetrievalTimeOut seja chamado antes de exibir a interface do usuário do código de verificação (não recomendado).

onCodeAutoRetrievalTimeOut(String verificaçãoId)

Opcional. Esse método é chamado após a duração do tempo limite especificada para verifyPhoneNumber ter 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 tenha expirado e só então exibem uma interface do usuário que solicita que o usuário digite o código de verificação da mensagem SMS (não recomendado).

Criar 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, para que possa pular esta etapa.)

Para criar o objeto PhoneAuthCredential , chame PhoneAuthProvider.getCredential :

Java

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

Kotlin+KTX

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

Faça login do 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 :

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

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

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. O teste com números de telefone fictícios oferece os seguintes 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 teste.
  • Teste prontamente em ambientes de desenvolvimento sem nenhum esforço adicional, como a capacidade de desenvolver em um simulador de iOS ou em um emulador de 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 são realmente fictícios e que ainda não existem. O Firebase Authentication não permite que você defina números de telefone existentes usados ​​por usuários reais como números de teste. Uma opção é usar 555 números prefixados como números de telefone de teste dos EUA, por exemplo: +1 650-555-3434
  2. Os números de telefone devem ser formatados corretamente para 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 difíceis de adivinhar e altere-os com frequência.

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

  1. No console do Firebase , abra a seção Autenticação .
  2. Na guia Método de login , habilite o provedor de telefone, caso ainda não tenha feito isso.
  3. Abra o menu Números de telefone para testar o acordeão.
  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.

Testes manuais

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 problemas de cota ou limitação. Você também pode testar diretamente de um simulador de iOS ou emulador de 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.

Ao concluir o login, um usuário do Firebase é criado com esse número de telefone. O usuário tem o mesmo comportamento e as mesmas 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 ID cunhado 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 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 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 desabilitam a verificação do aplicativo desativando o requisito reCAPTCHA na Web e notificações push silenciosas no iOS. Isso torna possível o teste de automação nesses fluxos e mais fácil de implementar. Além disso, eles ajudam a fornecer a capacidade de testar fluxos de verificação instantânea 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. Observe que, embora o reCAPTCHA e/ou SafetyNet estejam desativados, o uso de um número de telefone real ainda não completará 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 testar 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(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)

Além disso, você pode testar os 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 com o PhoneAuthCredential diretamente. Isso funciona apenas com números de telefone fictícios.

Verifique se isso está desativado e se nenhum número de telefone fictício está 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(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 entra pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais — ou seja, o nome de usuário e a 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 projeto, independentemente de como o usuário faça login.

  • Nos seus aplicativos, você pode obter as 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 de 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 :

Java

FirebaseAuth.getInstance().signOut();

Kotlin+KTX

Firebase.auth.signOut()