Acompanhe as novidades sobre tudo o que foi anunciado no Firebase Summit e saiba como o Firebase pode ajudar a acelerar o desenvolvimento de apps e executá-los com confiança. Saiba mais

Autenticar com o Firebase usando o link de e-mail no Android

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 a ele um e-mail contendo um link, no qual ele pode clicar para fazer login. No processo, o endereço de e-mail do usuário também é verificado.

Existem inúmeras vantagens em entrar por e-mail:

  • Inscrição e login de baixa fricção.
  • Menor risco de reutilização de senha em aplicativos, o que pode minar a segurança até mesmo de senhas bem selecionadas.
  • A capacidade de autenticar um usuário e, ao mesmo tempo, verificar se o usuário é o proprietário legítimo de um endereço de e-mail.
  • Um usuário só precisa de uma conta de e-mail acessível para entrar. Não é necessário possuir um número de telefone ou conta de mídia social.
  • Um usuário pode entrar com segurança sem a necessidade de fornecer (ou lembrar) uma senha, o que pode ser complicado em um dispositivo móvel.
  • Um usuário existente que se conectou anteriormente com um identificador de e-mail (senha ou federado) pode ser atualizado para se conectar apenas com o e-mail. Por exemplo, um usuário que esqueceu sua senha ainda pode entrar sem precisar redefinir sua senha.

Antes de você começar

Configure seu projeto Android

  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 para a biblioteca Firebase Authentication Android. Recomendamos usar o Firebase Android BoM para controlar o controle de versão da biblioteca.

    Além disso, como parte da configuração do Firebase Authentication, você precisa adicionar o Google Play Services SDK ao seu aplicativo.

    Kotlin+KTX

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:31.2.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'
    // Also add the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:20.4.1'
    }

    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 Firebase em sua linha de dependência.

    Observe que, se você usar várias bibliotecas do Firebase em seu aplicativo, recomendamos 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'
    // Also add the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:20.4.1'
    }

    Java

    dependencies {
        // Import the BoM for the Firebase platform
        implementation platform('com.google.firebase:firebase-bom:31.2.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'
    // Also add the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:20.4.1'
    }

    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 Firebase em sua linha de dependência.

    Observe que, se você usar várias bibliotecas do Firebase em seu aplicativo, recomendamos 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'
    // Also add the dependency for the Google Play services library and specify its version implementation 'com.google.android.gms:play-services-auth:20.4.1'
    }

Para fazer login de usuários por link de e-mail, você deve primeiro habilitar o provedor de e-mail e o método de login de link de e-mail para seu projeto do Firebase:

  1. No console do Firebase , abra a seção Auth .
  2. Na guia Método de login , ative o provedor de e- mail/senha . Observe que o login por e-mail/senha deve estar ativado para usar o login por link de email.
  3. Na mesma seção, ative o método de login com link de e-mail (entrada sem senha) .
  4. Clique em Salvar .

Para iniciar o fluxo de autenticação, apresente ao usuário uma interface que solicita que ele forneça seu endereço de e-mail e chame sendSignInLinkToEmail para solicitar que o Firebase envie o link de autenticação para o e-mail do usuário.

  1. Construa o objeto ActionCodeSettings , que fornece ao Firebase instruções sobre como construir o link de e-mail. Defina os seguintes campos:

    • url : o link profundo a ser incorporado e qualquer estado adicional a ser transmitido. O domínio do link deve estar na lista de permissões na lista de domínios autorizados do Firebase Console, que pode ser encontrada na guia Método de login (Autenticação -> Método de login). O link redirecionará o usuário para este URL se o aplicativo não estiver instalado em seu dispositivo e o aplicativo não puder ser instalado.
    • androidPackageName e IOSBundleId : os aplicativos a serem usados ​​quando o link de login é aberto em um dispositivo Android ou Apple. Saiba mais sobre como configurar o Firebase Dynamic Links para abrir links de ação de e-mail por meio de aplicativos móveis.
    • handleCodeInApp : definido como verdadeiro. A operação de login sempre deve ser concluída no aplicativo, ao contrário de outras ações de e-mail fora de banda (redefinição de senha e verificações de e-mail). Isso ocorre porque, ao final do fluxo, espera-se que o usuário esteja conectado e seu estado Auth persista no aplicativo.
    • dynamicLinkDomain : quando vários domínios de link dinâmico personalizados são definidos para um projeto, especifique qual usar quando o link for aberto por meio de um aplicativo móvel especificado (por exemplo, example.page.link ). Caso contrário, o primeiro domínio é selecionado automaticamente.

    Kotlin+KTX

    val actionCodeSettings = actionCodeSettings {
        // URL you want to redirect back to. The domain (www.example.com) for this
        // URL must be whitelisted in the Firebase Console.
        url = "https://www.example.com/finishSignUp?cartId=1234"
        // This must be true
        handleCodeInApp = true
        setIOSBundleId("com.example.ios")
        setAndroidPackageName(
                "com.example.android",
                true, /* installIfNotAvailable */
                "12" /* minimumVersion */)
    }

    Java

    ActionCodeSettings actionCodeSettings =
            ActionCodeSettings.newBuilder()
                    // URL you want to redirect back to. The domain (www.example.com) for this
                    // URL must be whitelisted in the Firebase Console.
                    .setUrl("https://www.example.com/finishSignUp?cartId=1234")
                    // This must be true
                    .setHandleCodeInApp(true)
                    .setIOSBundleId("com.example.ios")
                    .setAndroidPackageName(
                            "com.example.android",
                            true, /* installIfNotAvailable */
                            "12"    /* minimumVersion */)
                    .build();

    Para saber mais sobre ActionCodeSettings, consulte a seção Passing State in Email Actions .

  2. Peça ao usuário seu e-mail.

  3. Envie o link de autenticação para o e-mail do usuário e salve o e-mail do usuário caso ele conclua o login do e-mail no mesmo dispositivo.

    Kotlin+KTX

    Firebase.auth.sendSignInLinkToEmail(email, actionCodeSettings)
            .addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    Log.d(TAG, "Email sent.")
                }
            }

    Java

    FirebaseAuth auth = FirebaseAuth.getInstance();
    auth.sendSignInLinkToEmail(email, actionCodeSettings)
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                @Override
                public void onComplete(@NonNull Task<Void> task) {
                    if (task.isSuccessful()) {
                        Log.d(TAG, "Email sent.");
                    }
                }
            });

Preocupações com segurança

Para evitar que um link de login seja usado para fazer login como um usuário não intencional ou em um dispositivo não pretendido, o Firebase Auth exige que o endereço de e-mail do usuário seja fornecido ao concluir o fluxo de login. Para que o login seja bem-sucedido, esse endereço de e-mail deve corresponder ao endereço para o qual o link de login foi originalmente enviado.

Você pode simplificar esse fluxo para usuários que abrem o link de entrada no mesmo dispositivo em que solicitam o link, armazenando seu endereço de e-mail localmente - por exemplo, usando SharedPreferences - quando você envia o e-mail de entrada. Em seguida, use esse endereço para concluir o fluxo. Não passe o e-mail do usuário nos parâmetros de URL de redirecionamento e reutilize-o, pois isso pode permitir injeções de sessão.

Após a conclusão do login, qualquer mecanismo anterior de login não verificado será removido do usuário e todas as sessões existentes serão invalidadas. Por exemplo, se alguém criou anteriormente uma conta não verificada com o mesmo e-mail e senha, a senha do usuário será removida para impedir que o imitador que reivindicou a propriedade e criou essa conta não verificada entre novamente com o e-mail e a senha não verificados.

Certifique-se também de usar um URL HTTPS em produção para evitar que seu link seja potencialmente interceptado por servidores intermediários.

Concluindo o login em um aplicativo Android

O Firebase Authentication usa Firebase Dynamic Links para enviar o link de e-mail para um dispositivo móvel. Para a conclusão do login por meio do aplicativo móvel, o aplicativo deve ser configurado para detectar o link do aplicativo de entrada, analisar o link profundo subjacente e, em seguida, concluir o login.

O Firebase Auth usa Firebase Dynamic Links ao enviar um link que deve ser aberto em um aplicativo móvel. Para usar esse recurso, o Dynamic Links deve ser configurado no Console do Firebase.

  1. Ative os links dinâmicos do Firebase:

    1. No console do Firebase , abra a seção Dynamic Links .
    2. Se você ainda não aceitou os termos do Dynamic Links e criou um domínio do Dynamic Links, faça isso agora.

      Se você já criou um domínio do Dynamic Links, anote-o. Um domínio do Dynamic Links geralmente se parece com o exemplo a seguir:

      example.page.link

      Você precisará desse valor ao configurar seu aplicativo Apple ou Android para interceptar o link de entrada.

  2. Configurando aplicativos Android:

    1. Para lidar com esses links do seu aplicativo Android, o nome do pacote Android precisa ser especificado nas configurações do projeto Firebase Console. Além disso, o SHA-1 e o SHA-256 do certificado do aplicativo precisam ser fornecidos.
    2. Agora que você adicionou um domínio de link dinâmico e garantiu que seu aplicativo Android está configurado corretamente, o link dinâmico será redirecionado para seu aplicativo, começando pela atividade do iniciador.
    3. Se você deseja que o link dinâmico redirecione para uma atividade específica, será necessário configurar um filtro de intenção em seu arquivo AndroidManifest.xml . Isso pode ser feito especificando seu domínio de link dinâmico ou o manipulador de ação de e-mail no filtro de intenção. Por padrão, o manipulador de ação de email é hospedado em um domínio como o exemplo a seguir:
      PROJECT_ID.firebaseapp.com/
    4. Ressalvas:
      1. Não especifique a URL que você definiu em actionCodeSettings em seu filtro de intenção.
      2. Ao criar seu domínio de link dinâmico, você também pode ter criado um link de URL curto. Essa URL curta não será transmitida; não configure seu filtro de intenção para capturá-lo com um atributo android:pathPrefix . Isso significa que você não poderá capturar diferentes links dinâmicos em diferentes partes do seu aplicativo. No entanto, você pode verificar o parâmetro de consulta de mode no link para ver qual operação está tentando ser executada ou usar métodos SDK como isSignInWithEmailLink para ver se um link que seu aplicativo recebeu faz o que você deseja.
    5. Para saber mais sobre como receber links dinâmicos, consulte as instruções de recebimento de links dinâmicos do Android .

Depois de receber o link conforme descrito acima, verifique se ele se destina à autenticação de link de e-mail e conclua o login.

Kotlin+KTX

val auth = Firebase.auth
val intent = intent
val emailLink = intent.data.toString()

// Confirm the link is a sign-in with email link.
if (auth.isSignInWithEmailLink(emailLink)) {
    // Retrieve this from wherever you stored it
    val email = "someemail@domain.com"

    // The client SDK will parse the code from the link for you.
    auth.signInWithEmailLink(email, emailLink)
            .addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    Log.d(TAG, "Successfully signed in with email link!")
                    val result = task.result
                    // You can access the new user via result.getUser()
                    // Additional user info profile *not* available via:
                    // result.getAdditionalUserInfo().getProfile() == null
                    // You can check if the user is new or existing:
                    // result.getAdditionalUserInfo().isNewUser()
                } else {
                    Log.e(TAG, "Error signing in with email link", task.exception)
                }
            }
}

Java

FirebaseAuth auth = FirebaseAuth.getInstance();
Intent intent = getIntent();
String emailLink = intent.getData().toString();

// Confirm the link is a sign-in with email link.
if (auth.isSignInWithEmailLink(emailLink)) {
    // Retrieve this from wherever you stored it
    String email = "someemail@domain.com";

    // The client SDK will parse the code from the link for you.
    auth.signInWithEmailLink(email, emailLink)
            .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        Log.d(TAG, "Successfully signed in with email link!");
                        AuthResult result = task.getResult();
                        // You can access the new user via result.getUser()
                        // Additional user info profile *not* available via:
                        // result.getAdditionalUserInfo().getProfile() == null
                        // You can check if the user is new or existing:
                        // result.getAdditionalUserInfo().isNewUser()
                    } else {
                        Log.e(TAG, "Error signing in with email link", task.getException());
                    }
                }
            });
}

Para saber mais sobre como lidar com o login com link de e-mail em um aplicativo da Apple, consulte o guia de plataformas da Apple .

Para saber como lidar com o login com link de e-mail em um aplicativo da web, consulte o guia da web .

Você também pode vincular esse método de autenticação a um usuário existente. Por exemplo, um usuário previamente autenticado com outro provedor, como um número de telefone, pode adicionar esse método de login à sua conta existente.

A diferença estaria na segunda metade da operação:

Kotlin+KTX

// Construct the email link credential from the current URL.
val credential = EmailAuthProvider.getCredentialWithLink(email, emailLink)

// Link the credential to the current user.
Firebase.auth.currentUser!!.linkWithCredential(credential)
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                Log.d(TAG, "Successfully linked emailLink credential!")
                val result = task.result
                // You can access the new user via result.getUser()
                // Additional user info profile *not* available via:
                // result.getAdditionalUserInfo().getProfile() == null
                // You can check if the user is new or existing:
                // result.getAdditionalUserInfo().isNewUser()
            } else {
                Log.e(TAG, "Error linking emailLink credential", task.exception)
            }
        }

Java

// Construct the email link credential from the current URL.
AuthCredential credential =
        EmailAuthProvider.getCredentialWithLink(email, emailLink);

// Link the credential to the current user.
auth.getCurrentUser().linkWithCredential(credential)
        .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isSuccessful()) {
                    Log.d(TAG, "Successfully linked emailLink credential!");
                    AuthResult result = task.getResult();
                    // You can access the new user via result.getUser()
                    // Additional user info profile *not* available via:
                    // result.getAdditionalUserInfo().getProfile() == null
                    // You can check if the user is new or existing:
                    // result.getAdditionalUserInfo().isNewUser()
                } else {
                    Log.e(TAG, "Error linking emailLink credential", task.getException());
                }
            }
        });

Isso também pode ser usado para autenticar novamente um usuário de link de e-mail antes de executar uma operação confidencial.

Kotlin+KTX

// Construct the email link credential from the current URL.
val credential = EmailAuthProvider.getCredentialWithLink(email, emailLink)

// Re-authenticate the user with this credential.
Firebase.auth.currentUser!!.reauthenticateAndRetrieveData(credential)
        .addOnCompleteListener { task ->
            if (task.isSuccessful) {
                // User is now successfully reauthenticated
            } else {
                Log.e(TAG, "Error reauthenticating", task.exception)
            }
        }

Java

// Construct the email link credential from the current URL.
AuthCredential credential =
        EmailAuthProvider.getCredentialWithLink(email, emailLink);

// Re-authenticate the user with this credential.
auth.getCurrentUser().reauthenticateAndRetrieveData(credential)
        .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isSuccessful()) {
                    // User is now successfully reauthenticated
                } else {
                    Log.e(TAG, "Error reauthenticating", task.getException());
                }
            }
        });

No entanto, como o fluxo pode terminar em um dispositivo diferente no qual o usuário original não estava conectado, esse fluxo pode não ser concluído. Nesse caso, um erro pode ser mostrado ao usuário para forçá-lo a abrir o link no mesmo dispositivo. Algum estado pode ser passado no link para fornecer informações sobre o tipo de operação e o uid do usuário.

Caso você ofereça suporte a login baseado em senha e link com e-mail, para diferenciar o método de login para um usuário de senha/link, use fetchSignInMethodsForEmail . Isso é útil para fluxos de identificador primeiro em que o usuário primeiro é solicitado a fornecer seu e-mail e, em seguida, apresenta o método de login:

Kotlin+KTX

Firebase.auth.fetchSignInMethodsForEmail(email)
        .addOnSuccessListener { result ->
            val signInMethods = result.signInMethods!!
            if (signInMethods.contains(EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD)) {
                // User can sign in with email/password
            } else if (signInMethods.contains(EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD)) {
                // User can sign in with email/link
            }
        }
        .addOnFailureListener { exception ->
            Log.e(TAG, "Error getting sign in methods for user", exception)
        }

Java

auth.fetchSignInMethodsForEmail(email)
        .addOnCompleteListener(new OnCompleteListener<SignInMethodQueryResult>() {
            @Override
            public void onComplete(@NonNull Task<SignInMethodQueryResult> task) {
                if (task.isSuccessful()) {
                    SignInMethodQueryResult result = task.getResult();
                    List<String> signInMethods = result.getSignInMethods();
                    if (signInMethods.contains(EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD)) {
                        // User can sign in with email/password
                    } else if (signInMethods.contains(EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD)) {
                        // User can sign in with email/link
                    }
                } else {
                    Log.e(TAG, "Error getting sign in methods for user", task.getException());
                }
            }
        });

Conforme descrito acima, e-mail/senha e e-mail/link são considerados o mesmo EmailAuthProvider (mesmo PROVIDER_ID ) com diferentes métodos de login.

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.

  • Em 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 Cloud Storage , você pode obter o ID de usuário exclusivo do usuário conectado a partir da 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 em 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();