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 nas plataformas da Apple 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 único contido na mensagem SMS.

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

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.
E, confira uma etapa de configuração:
  1. Se você ainda não conectou seu aplicativo ao projeto do Firebase, faça-o no console do Firebase .

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 os usuários. Além disso, em dispositivos com vários perfis de usuário, qualquer usuário que receba mensagens SMS pode fazer login em uma conta usando o número de telefone do dispositivo.

Se você usar o login com base no 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 e desvantagens de usar o login com número de telefone.

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

Para fazer login de usuários por SMS, você deve primeiro habilitar o método de login Phone Number para seu projeto 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 Número de telefone .

A cota de solicitação de login de 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 verificação de aplicativo

Para usar a autenticação de número de telefone, o Firebase deve ser capaz de verificar se as solicitações de login do número de telefone vêm do seu aplicativo. Há duas maneiras de o Firebase Authentication fazer isso:

  • Notificações de APNs silenciosas : quando você faz login de um usuário com seu número de telefone pela primeira vez em um dispositivo, o Firebase Authentication envia um token para o dispositivo usando uma notificação por push silenciosa. Se seu aplicativo receber com sucesso a notificação do Firebase, o login do número de telefone poderá continuar.

    Para iOS 8.0 e mais recente, as notificações silenciosas não exigem consentimento explícito do usuário e, portanto, não são afetadas por um usuário que se recusa a receber notificações de APNs no aplicativo. Assim, o aplicativo não precisa solicitar permissão do usuário para receber notificações push ao implementar a autenticação do número de telefone do Firebase.

  • Verificação reCAPTCHA : Caso não seja possível enviar ou receber uma notificação push silenciosa, como quando o usuário desativou a atualização em segundo plano para seu aplicativo ou ao testar seu aplicativo em um simulador iOS, o Firebase Authentication usa a verificação reCAPTCHA para concluir o telefone fluxo de entrada. Muitas vezes, o desafio reCAPTCHA pode ser concluído sem que o usuário precise resolver nada.

Quando as notificações push silenciosas são configuradas corretamente, apenas uma porcentagem muito pequena de usuários experimentará o fluxo reCAPTCHA. No entanto, você deve garantir que o login do número de telefone funcione corretamente, independentemente de as notificações por push silenciosas estarem disponíveis ou não.

Comece a receber notificações silenciosas

Para ativar as notificações de APNs para uso com o Firebase Authentication:

  1. No Xcode, ative as notificações por push para seu projeto.
  2. Carregue sua chave de autenticação de APNs para o Firebase. Se você ainda não tiver uma chave de autenticação de APNs, certifique-se de criar uma no Apple Developer Member Center .

    1. Dentro do seu projeto no Firebase console, selecione o ícone de engrenagem, selecione Project Settings e, em seguida, selecione a guia Cloud Messaging .

    2. Em Chave de autenticação de APNs em Configuração do aplicativo iOS , clique no botão Carregar .

    3. Navegue até o local onde você salvou sua chave, selecione-a e clique em Abrir . Adicione o ID da chave (disponível no Apple Developer Member Center ) e clique em Upload .

    Se você já tiver um certificado de APNs, poderá fazer o upload do certificado.

Configurar a verificação do reCAPTCHA

Para permitir que o Firebase SDK use a verificação reCAPTCHA:

  1. Adicione esquemas de URL personalizados ao seu projeto Xcode:
    1. Abra a configuração do seu projeto: clique duas vezes no nome do projeto na visualização em árvore à esquerda. Selecione seu aplicativo na seção TARGETS , selecione a guia Info e expanda a seção URL Types .
    2. Clique no botão + e adicione um esquema de URL para seu ID de cliente invertido. Para encontrar esse valor, abra o arquivo de configuração GoogleService-Info.plist e procure a chave REVERSED_CLIENT_ID . Copie o valor dessa chave e cole-o na caixa Esquemas de URL na página de configuração. Deixe os outros campos em branco.

      Quando concluída, sua configuração deve ser semelhante à seguinte (mas com os valores específicos do aplicativo):

  2. Opcional : se você quiser personalizar a maneira como seu aplicativo apresenta o SFSafariViewController ao exibir o reCAPTCHA para o usuário, crie uma classe personalizada que esteja em conformidade com o protocolo AuthUIDelegate e passe-a para verifyPhoneNumber(_:uiDelegate:completion:) .

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 forneça seu número de telefone e, em seguida, chame verifyPhoneNumber(_:uiDelegate:completion:) para solicitar que o Firebase envie um código de autenticação para o telefone do usuário por SMS:

  1. Obtenha o número de telefone do usuário.

    Os requisitos legais variam, mas como prática recomendada e para definir expectativas para seus usuários, você deve informá-los de que, se eles usarem login por telefone, poderão receber uma mensagem SMS para verificação e taxas padrão aplicáveis.

  2. Ligue verifyPhoneNumber(_:uiDelegate:completion:) , passando para ele o número de telefone do usuário.

    Rápido

    PhoneAuthProvider.provider()
      .verifyPhoneNumber(phoneNumber, uiDelegate: nil) { verificationID, error in
          if let error = error {
            self.showMessagePrompt(error.localizedDescription)
            return
          }
          // Sign in using the verificationID and the code sent to the user
          // ...
      }

    Objective-C

    [[FIRPhoneAuthProvider provider] verifyPhoneNumber:userInput
                                            UIDelegate:nil
                                            completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
      if (error) {
        [self showMessagePrompt:error.localizedDescription];
        return;
      }
      // Sign in using the verificationID and the code sent to the user
      // ...
    }];

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

    Quando você chama verifyPhoneNumber(_:uiDelegate:completion:) , o Firebase envia uma notificação push silenciosa para seu aplicativo ou emite um desafio reCAPTCHA para o usuário. Depois que seu aplicativo recebe a notificação ou o usuário conclui o desafio reCAPTCHA, o Firebase envia uma mensagem SMS contendo um código de autenticação para o número de telefone especificado e passa um ID de verificação para sua função de conclusão. Você precisará do código de verificação e da ID de verificação para fazer login como usuário.

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

    Rápido

     // Change language code to french.
     Auth.auth().languageCode = "fr";
    

    Objective-C

     // Change language code to french.
     [FIRAuth auth].languageCode = @"fr";
    
  3. Salve o ID de verificação e restaure-o quando o aplicativo for carregado. Ao fazer isso, você pode garantir que ainda tenha uma ID de verificação válida se seu aplicativo for encerrado antes que o usuário conclua o fluxo de login (por exemplo, ao alternar para o aplicativo de SMS).

    Você pode manter o ID de verificação da maneira que desejar. Uma maneira simples é salvar o ID de verificação com o objeto NSUserDefaults :

    Rápido

    UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
    

    Objective-C

    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    [defaults setObject:verificationID forKey:@"authVerificationID"];
    

    Então, você pode restaurar o valor salvo:

    Rápido

    let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
    

    Objective-C

    NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
    

Se a chamada para verifyPhoneNumber(_:uiDelegate:completion:) for bem-sucedida, você poderá solicitar que o usuário digite o código de verificação ao recebê-lo na mensagem SMS.

Faça login do usuário com o código de verificação

Depois que o usuário fornecer ao seu aplicativo o código de verificação da mensagem SMS, conecte o usuário criando um objeto FIRPhoneAuthCredential a partir do código de verificação e da ID de verificação e passando esse objeto para signInWithCredential:completion: .

  1. Obtenha o código de verificação do usuário.
  2. Crie um objeto FIRPhoneAuthCredential a partir do código de verificação e da ID de verificação.

    Rápido

    let credential = PhoneAuthProvider.provider().credential(
      withVerificationID: verificationID,
      verificationCode: verificationCode
    )

    Objective-C

    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
        credentialWithVerificationID:verificationID
                    verificationCode:userInput];
  3. Faça login do usuário com o objeto FIRPhoneAuthCredential :

    Rápido

    Auth.auth().signIn(with: credential) { authResult, error in
        if let error = error {
          let authError = error as NSError
          if isMFAEnabled, authError.code == AuthErrorCode.secondFactorRequired.rawValue {
            // The user is a multi-factor user. Second factor challenge is required.
            let resolver = authError
              .userInfo[AuthErrorUserInfoMultiFactorResolverKey] as! MultiFactorResolver
            var displayNameString = ""
            for tmpFactorInfo in resolver.hints {
              displayNameString += tmpFactorInfo.displayName ?? ""
              displayNameString += " "
            }
            self.showTextInputPrompt(
              withMessage: "Select factor to sign in\n\(displayNameString)",
              completionBlock: { userPressedOK, displayName in
                var selectedHint: PhoneMultiFactorInfo?
                for tmpFactorInfo in resolver.hints {
                  if displayName == tmpFactorInfo.displayName {
                    selectedHint = tmpFactorInfo as? PhoneMultiFactorInfo
                  }
                }
                PhoneAuthProvider.provider()
                  .verifyPhoneNumber(with: selectedHint!, uiDelegate: nil,
                                     multiFactorSession: resolver
                                       .session) { verificationID, error in
                    if error != nil {
                      print(
                        "Multi factor start sign in failed. Error: \(error.debugDescription)"
                      )
                    } else {
                      self.showTextInputPrompt(
                        withMessage: "Verification code for \(selectedHint?.displayName ?? "")",
                        completionBlock: { userPressedOK, verificationCode in
                          let credential: PhoneAuthCredential? = PhoneAuthProvider.provider()
                            .credential(withVerificationID: verificationID!,
                                        verificationCode: verificationCode!)
                          let assertion: MultiFactorAssertion? = PhoneMultiFactorGenerator
                            .assertion(with: credential!)
                          resolver.resolveSignIn(with: assertion!) { authResult, error in
                            if error != nil {
                              print(
                                "Multi factor finanlize sign in failed. Error: \(error.debugDescription)"
                              )
                            } else {
                              self.navigationController?.popViewController(animated: true)
                            }
                          }
                        }
                      )
                    }
                  }
              }
            )
          } else {
            self.showMessagePrompt(error.localizedDescription)
            return
          }
          // ...
          return
        }
        // User is signed in
        // ...
    }

    Objective-C

    [[FIRAuth auth] signInWithCredential:credential
                              completion:^(FIRAuthDataResult * _Nullable authResult,
                                           NSError * _Nullable error) {
        if (isMFAEnabled && error && error.code == FIRAuthErrorCodeSecondFactorRequired) {
          FIRMultiFactorResolver *resolver = error.userInfo[FIRAuthErrorUserInfoMultiFactorResolverKey];
          NSMutableString *displayNameString = [NSMutableString string];
          for (FIRMultiFactorInfo *tmpFactorInfo in resolver.hints) {
            [displayNameString appendString:tmpFactorInfo.displayName];
            [displayNameString appendString:@" "];
          }
          [self showTextInputPromptWithMessage:[NSString stringWithFormat:@"Select factor to sign in\n%@", displayNameString]
                               completionBlock:^(BOOL userPressedOK, NSString *_Nullable displayName) {
           FIRPhoneMultiFactorInfo* selectedHint;
           for (FIRMultiFactorInfo *tmpFactorInfo in resolver.hints) {
             if ([displayName isEqualToString:tmpFactorInfo.displayName]) {
               selectedHint = (FIRPhoneMultiFactorInfo *)tmpFactorInfo;
             }
           }
           [FIRPhoneAuthProvider.provider
            verifyPhoneNumberWithMultiFactorInfo:selectedHint
            UIDelegate:nil
            multiFactorSession:resolver.session
            completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
              if (error) {
                [self showMessagePrompt:error.localizedDescription];
              } else {
                [self showTextInputPromptWithMessage:[NSString stringWithFormat:@"Verification code for %@", selectedHint.displayName]
                                     completionBlock:^(BOOL userPressedOK, NSString *_Nullable verificationCode) {
                 FIRPhoneAuthCredential *credential =
                     [[FIRPhoneAuthProvider provider] credentialWithVerificationID:verificationID
                                                                  verificationCode:verificationCode];
                 FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
                 [resolver resolveSignInWithAssertion:assertion completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
                   if (error) {
                     [self showMessagePrompt:error.localizedDescription];
                   } else {
                     NSLog(@"Multi factor finanlize sign in succeeded.");
                   }
                 }];
               }];
              }
            }];
         }];
        }
      else if (error) {
        // ...
        return;
      }
      // User successfully signed in. Get user data from the FIRUser object
      if (authResult == nil) { return; }
      FIRUser *user = authResult.user;
      // ...
    }];

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 loja de aplicativos 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 de iOS ou 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 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 555 números com prefixo 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 para comprimento e outras restrições. Eles ainda passarão pela mesma validação do 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 , ative o Provedor de telefone, caso ainda não o tenha feito.
  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.

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 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 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 forma. O token de ID criado 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.

Teste de integração

Além do teste manual, 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 as notificações por push silenciosas no iOS. Isso torna o teste de automação possível 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 iOS, a configuração appVerificationDisabledForTesting deve ser definida como TRUE antes de chamar verifyPhoneNumber . Isso é processado sem exigir nenhum token de APNs ou enviar notificações push silenciosas em segundo plano, facilitando o teste em um simulador. Isso também desativa o fluxo de fallback do reCAPTCHA.

Observe que, quando a verificação do aplicativo está desativada, o uso de um número de telefone não fictício falhará na conclusão do login. Somente números de telefone fictícios podem ser usados ​​com esta API.

Rápido

let phoneNumber = "+16505554567"

// This test verification code is specified for the given test phone number in the developer console.
let testVerificationCode = "123456"

Auth.auth().settings.isAppVerificationDisabledForTesting = TRUE
PhoneAuthProvider.provider().verifyPhoneNumber(phoneNumber, uiDelegate:nil) {
                                                            verificationID, error in
    if (error) {
      // Handles error
      self.handleError(error)
      return
    }
    let credential = PhoneAuthProvider.provider().credential(withVerificationID: verificationID ?? "",
                                                               verificationCode: testVerificationCode)
    Auth.auth().signInAndRetrieveData(with: credential) { authData, error in
      if (error) {
        // Handles error
        self.handleError(error)
        return
      }
      _user = authData.user
    }];
}];

Objective-C

NSString *phoneNumber = @"+16505554567";

// This test verification code is specified for the given test phone number in the developer console.
NSString *testVerificationCode = @"123456";

[FIRAuth auth].settings.appVerificationDisabledForTesting = YES;
[[FIRPhoneAuthProvider provider] verifyPhoneNumber:phoneNumber
                                        completion:^(NSString *_Nullable verificationID,
                                                     NSError *_Nullable error) {
    if (error) {
      // Handles error
      [self handleError:error];
      return;
    }
    FIRAuthCredential *credential =
        [FIRPhoneAuthProvider credentialWithVerificationID:verificationID
                                          verificationCode:testVerificationCode];
    [FIRAuth auth] signInWithAndRetrieveDataWithCredential:credential
                                                completion:^(FIRUser *_Nullable user,
                                                             NSError *_Nullable error) {
      if (error) {
        // Handles error
        [self handleError:error];
        return;
      }
      _user = user;
    }];
}];

Apêndice: Usando o login do telefone sem swizzling

A Autenticação do Firebase usa o método swizzling para obter automaticamente o token de APNs do seu aplicativo, para lidar com as notificações push silenciosas que o Firebase envia para o seu aplicativo e para interceptar automaticamente o redirecionamento de esquema personalizado da página de verificação do reCAPTCHA durante a verificação.

Se preferir não usar swizzling, você pode desativá-lo adicionando o sinalizador FirebaseAppDelegateProxyEnabled ao arquivo Info.plist do seu aplicativo e definindo-o como NO . Observe que definir esse sinalizador como NO também desativa o swizzling para outros produtos Firebase, incluindo Firebase Cloud Messaging.

Se você desabilitar o swizzling, deverá passar explicitamente o token do dispositivo APNs, as notificações por push e o URL de redirecionamento do esquema personalizado para o Firebase Authentication.

Se estiver criando um aplicativo SwiftUI, você também deve passar explicitamente o token do dispositivo APNs, as notificações por push e o URL de redirecionamento de esquema personalizado para o Firebase Authentication.

Para obter o token do dispositivo APNs, implemente o método application(_:didRegisterForRemoteNotificationsWithDeviceToken:) e, nele, passe o token do dispositivo para o setAPNSToken(_:type:) de Auth .

Rápido

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
  // Pass device token to auth
  Auth.auth().setAPNSToken(deviceToken, type: .prod)

  // Further handling of the device token if needed by the app
  // ...
}

Objective-C

- (void)application:(UIApplication *)application
    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
  // Pass device token to auth.
  [[FIRAuth auth] setAPNSToken:deviceToken type:FIRAuthAPNSTokenTypeProd];
  // Further handling of the device token if needed by the app.
}

Para lidar com notificações push, no método application(_:didReceiveRemoteNotification:fetchCompletionHandler:): verifique as notificações relacionadas à autenticação do Firebase chamando o método canHandleNotification(_:) de Auth .

Rápido

func application(_ application: UIApplication,
    didReceiveRemoteNotification notification: [AnyHashable : Any],
    fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
  if Auth.auth().canHandleNotification(notification) {
    completionHandler(.noData)
    return
  }
  // This notification is not auth related; it should be handled separately.
}

Objective-C

- (void)application:(UIApplication *)application
    didReceiveRemoteNotification:(NSDictionary *)notification
          fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
  // Pass notification to auth and check if they can handle it.
  if ([[FIRAuth auth] canHandleNotification:notification]) {
    completionHandler(UIBackgroundFetchResultNoData);
    return;
  }
  // This notification is not auth related; it should be handled separately.
}

Para manipular a URL de redirecionamento do esquema personalizado, implemente o método application(_:open:options:) e, neles, passe a URL para o método canHandleURL(_:) de Auth .

Rápido

func application(_ application: UIApplication, open url: URL,
    options: [UIApplicationOpenURLOptionsKey : Any]) -> Bool {
  if Auth.auth().canHandle(url) {
    return true
  }
  // URL not auth related; it should be handled separately.
}

Objective-C

- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  if ([[FIRAuth auth] canHandleURL:url]) {
    return YES;
  }
  // URL not auth related; it should be handled separately.
}

Se você estiver usando SwiftUI ou UISceneDelegate , para manipular a URL de redirecionamento, implemente o método scene(_:openURLContexts:) e, neles, passe a URL para o método canHandleURL(_:) de Auth .

Rápido

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
  for urlContext in URLContexts {
      let url = urlContext.url
      Auth.auth().canHandle(url)
  }
  // URL not auth related; it should be handled separately.
}

Objective-C

- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
  for (UIOpenURLContext *urlContext in URLContexts) {
    [FIRAuth.auth canHandleURL:urlContext.url];
    // URL not auth related; it should be handled separately.
  }
}

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 do objeto FIRUser . 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 .