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 nas plataformas da Apple

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

Use o Swift Package Manager para instalar e gerenciar dependências do Firebase.

  1. No Xcode, com seu projeto de aplicativo aberto, navegue até File > Add Packages .
  2. Quando solicitado, adicione o repositório Firebase Apple Platform SDK:
  3.   https://github.com/firebase/firebase-ios-sdk
  4. Escolha a biblioteca Firebase Authentication.
  5. Quando terminar, o Xcode começará automaticamente a resolver e baixar suas dependências em segundo plano.

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 sendSignInLink 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).
    • iOSBundleID e androidPackageName : 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.

    Rápido

    let actionCodeSettings = ActionCodeSettings()
    actionCodeSettings.url = URL(string: "https://www.example.com")
    // The sign-in operation has to always be completed in the app.
    actionCodeSettings.handleCodeInApp = true
    actionCodeSettings.setIOSBundleID(Bundle.main.bundleIdentifier!)
    actionCodeSettings.setAndroidPackageName("com.example.android",
                                             installIfNotAvailable: false, minimumVersion: "12")
    

    Objective-C

    FIRActionCodeSettings *actionCodeSettings = [[FIRActionCodeSettings alloc] init];
    [actionCodeSettings setURL:[NSURL URLWithString:@"https://www.example.com"]];
    // The sign-in operation has to always be completed in the app.
    actionCodeSettings.handleCodeInApp = YES;
    [actionCodeSettings setIOSBundleID:[[NSBundle mainBundle] bundleIdentifier]];
    [actionCodeSettings setAndroidPackageName:@"com.example.android"
                        installIfNotAvailable:NO
                               minimumVersion:@"12"];
    

    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.

    Rápido

    Auth.auth().sendSignInLink(toEmail: email,
                               actionCodeSettings: actionCodeSettings) { error in
      // ...
        if let error = error {
          self.showMessagePrompt(error.localizedDescription)
          return
        }
        // The link was successfully sent. Inform the user.
        // Save the email locally so you don't need to ask the user for it again
        // if they open the link on the same device.
        UserDefaults.standard.set(email, forKey: "Email")
        self.showMessagePrompt("Check your email for link")
        // ...
    }
    

    Objective-C

    [[FIRAuth auth] sendSignInLinkToEmail:email
                       actionCodeSettings:actionCodeSettings
                               completion:^(NSError *_Nullable error) {
      // ...
        if (error) {
          [self showMessagePrompt:error.localizedDescription];
           return;
        }
        // The link was successfully sent. Inform the user.
        // Save the email locally so you don't need to ask the user for it again
        // if they open the link on the same device.
        [NSUserDefaults.standardUserDefaults setObject:email forKey:@"Email"];
        [self showMessagePrompt:@"Check your email for link"];
        // ...
    }];
    

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 login no mesmo dispositivo em que solicitam o link, armazenando seu endereço de e-mail localmente quando você envia o e-mail de login. Em seguida, use esse endereço para concluir o fluxo.

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 faça login novamente com a mesma conta.

Concluindo o login em um aplicativo móvel da Apple

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 precisa 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 da Apple:

    1. Se você planeja lidar com esses links de seu aplicativo, o ID do pacote precisa ser especificado nas configurações do projeto do Firebase Console. Além disso, o ID da App Store e o ID da equipe de desenvolvedores da Apple também precisam ser especificados.
    2. Você também precisará configurar seu domínio do manipulador de ação de e-mail como um Domínio Associado em seus recursos de aplicativo. Por padrão, o manipulador de ação de e-mail é hospedado em um domínio como o exemplo a seguir:
      APP_ID.firebaseapp.com
    3. Se você planeja distribuir seu aplicativo para iOS versões 8 e anteriores, você precisará definir seu ID de pacote como um esquema personalizado para URLs de entrada.
    4. Para saber mais sobre isso, consulte Recebendo instruções de links dinâmicos da plataforma Apple .

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

Rápido

if Auth.auth().isSignIn(withEmailLink: link) {
        Auth.auth().signIn(withEmail: email, link: self.link) { user, error in
          // ...
        }
}

Objective-C

if ([[FIRAuth auth] isSignInWithEmailLink:link]) {
    [[FIRAuth auth] signInWithEmail:email
                               link:link
                         completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
      // ...
    }];
}

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

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:

Rápido

  let credential = EmailAuthCredential.credential(withEmail:email
                                                       link:link)
  Auth.auth().currentUser?.link(with: credential) { authData, error in
    if (error) {
      // And error occurred during linking.
      return
    }
    // The provider was successfully linked.
    // The phone user can now sign in with their phone number or email.
  }

Objective-C

  FIRAuthCredential *credential =
      [FIREmailAuthProvider credentialWithEmail:email link:link];
  [FIRAuth auth].currentUser
      linkWithCredential:credential
              completion:^(FIRAuthDataResult *_Nullable result,
                           NSError *_Nullable error) {
    if (error) {
      // And error occurred during linking.
      return;
    }
    // The provider was successfully linked.
    // The phone user can now sign in with their phone number or email.
  }];

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

Rápido

  let credential = EmailAuthProvider.credential(withEmail:email
                                                       link:link)
  Auth.auth().currentUser?.reauthenticate(with: credential) { authData, error in
    if (error) {
      // And error occurred during re-authentication.
      return
    }
    // The user was successfully re-authenticated.
  }

Objective-C

  FIRAuthCredential *credential =
      [FIREmailAuthCredential credentialWithEmail:email link:link];
  [FIRAuth auth].currentUser
      reauthenticateWithCredential:credential
                        completion:^(FIRAuthDataResult *_Nullable result,
                                     NSError *_Nullable error) {
    if (error) {
      // And error occurred during re-authentication
      return;
    }
    // The user was successfully re-authenticated.
  }];

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:

Rápido

 // After asking the user for their email.
 Auth.auth().fetchSignInMethods(forEmail: email) { signInMethods, error in
   // This returns the same array as fetchProviders(forEmail:completion:) but for email
   // provider identified by 'password' string, signInMethods would contain 2
   // different strings:
   // 'emailLink' if the user previously signed in with an email/link
   // 'password' if the user has a password.
   // A user could have both.
   if (error) {
     // Handle error case.
   }
   if (!signInMethods.contains(EmailPasswordAuthSignInMethod)) {
     // User can sign in with email/password.
   }
   if (!signInMethods.contains(EmailLinkAuthSignInMethod)) {
     // User can sign in with email/link.
   }
 }

Objective-C

 // After asking the user for their email.
 [FIRAuth auth] fetchSignInMethodsForEmail:email
                                completion:^(NSArray *_Nullable signInMethods,
                                             NSError *_Nullable error) {
   // This returns the same array as fetchProvidersForEmail but for email
   // provider identified by 'password' string, signInMethods would contain 2
   // different strings:
   // 'emailLink' if the user previously signed in with an email/link
   // 'password' if the user has a password.
   // A user could have both.
   if (error) {
     // Handle error case.
   }
   if (![signInMethods containsObject:FIREmailPasswordAuthSignInMethod]) {
     // User can sign in with email/password.
   }
   if (![signInMethods containsObject:FIREmailLinkAuthSignInMethod]) {
     // User can sign in with email/link.
   }
 }];

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 User no objeto Usuário. 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: .

Rápido

    let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}
  

Objective-C

    NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Você também pode querer adicionar código de tratamento de erros para toda a gama de erros de autenticação. Consulte Tratar erros .