Você pode usar o Firebase Authentication para fazer login de um usuário enviando uma mensagem SMS para o telefone do usuário. O usuário faz login usando um código único contido na mensagem SMS.
A maneira mais fácil de adicionar login por número de telefone ao seu aplicativo é usar o FirebaseUI, que inclui um widget de login drop-in que implementa fluxos de login para login por número de telefone, bem como login federado e baseado em senha -em. Este documento descreve como implementar um fluxo de login por número de telefone usando o SDK do Firebase.
Antes de você começar
- Se você ainda não conectou seu aplicativo ao projeto do Firebase, faça isso no console do Firebase .
Use o Swift Package Manager para instalar e gerenciar dependências do Firebase.
- No Xcode, com o projeto do seu aplicativo aberto, navegue até File > Add Packages .
- Quando solicitado, adicione o repositório SDK das plataformas Apple do Firebase:
- Escolha a biblioteca Firebase Authentication.
- Adicione o sinalizador
-ObjCà seção Outros sinalizadores de vinculador das configurações de compilação do seu destino. - Quando terminar, o Xcode começará automaticamente a resolver e baixar suas dependências em segundo plano.
https://github.com/firebase/firebase-ios-sdk.git
Preocupações com segurança
A autenticação usando apenas um número de telefone, embora conveniente, é menos segura do que outros métodos disponíveis, porque a posse de um número de telefone pode ser facilmente transferida entre usuários. Além disso, em dispositivos com vários perfis de usuário, qualquer usuário que possa receber mensagens SMS poderá fazer login em uma conta usando o número de telefone do dispositivo.
Se você usar o login baseado em número de telefone em seu aplicativo, deverá oferecê-lo junto com métodos de login mais seguros e informar os usuários sobre as desvantagens de segurança do uso do login por número de telefone.
Ative o login com número de telefone para seu projeto do Firebase
Para fazer login de usuários por SMS, primeiro você precisa ativar o método de login por número de telefone para seu projeto do Firebase:
- No console do Firebase , abra a seção Autenticação .
- Na página Método de login , habilite o método de login com número de telefone .
A cota de solicitações de login por número de telefone do Firebase é alta o suficiente para que a maioria dos aplicativos não seja afetada. No entanto, se você precisar conectar um volume muito grande de usuários com autenticação por telefone, talvez seja necessário atualizar seu plano de preços. Veja a página de preços .
Ativar verificação de aplicativos
Para usar a autenticação por número de telefone, o Firebase precisa ser capaz de verificar se as solicitações de login por número de telefone vêm do seu aplicativo. Existem duas maneiras pelas quais o Firebase Authentication faz isso:
- Notificações silenciosas de APNs : 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 ao dispositivo usando uma notificação push silenciosa. Se o seu aplicativo receber a notificação do Firebase, o login do número de telefone poderá prosseguir.
Para iOS 8.0 e versões mais recentes, as notificações silenciosas não exigem o consentimento explícito do usuário e, portanto, não são afetadas pela recusa do usuário em 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 de 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 do 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 login. O desafio do reCAPTCHA muitas vezes pode ser concluído sem que o usuário precise resolver nada.
Quando as notificações push silenciosas são configuradas corretamente, apenas uma pequena porcentagem 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 push silenciosas estarem disponíveis ou não.
Comece a receber notificações silenciosas
Para ativar notificações de APNs para uso com o Firebase Authentication:
- No Xcode, habilite notificações push para seu projeto.
Faça upload da sua chave de autenticação de APNs para o Firebase. Se você ainda não possui uma chave de autenticação de APNs, crie uma no Apple Developer Member Center .
Dentro do seu projeto no console do Firebase, selecione o ícone de engrenagem, selecione Configurações do projeto e selecione a guia Cloud Messaging .
Na chave de autenticação APNs em configuração do aplicativo iOS , clique no botão Upload .
Navegue até o local onde você salvou sua chave, selecione-o 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 upload do certificado.
Configurar a verificação reCAPTCHA
Para permitir que o SDK do Firebase use a verificação reCAPTCHA:
- Adicione esquemas de URL personalizados ao seu projeto Xcode:
- 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 Informações e expanda a seção Tipos de URL .
- Clique no botão + e adicione seu ID de aplicativo codificado como um esquema de URL. Você pode encontrar o ID do aplicativo codificado na página Configurações gerais do console do Firebase, na seção do seu aplicativo iOS. Deixe os outros campos em branco.
Quando concluída, sua configuração deverá ser semelhante à seguinte (mas com os valores específicos do seu aplicativo):
- Opcional : se você quiser personalizar a maneira como seu aplicativo apresenta o
SFSafariViewControllerao exibir o reCAPTCHA para o usuário, crie uma classe personalizada que esteja em conformidade com o protocoloAuthUIDelegatee passe-a paraverifyPhoneNumber(_:uiDelegate:completion:).
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 forneça seu número de telefone e, em seguida, ligue verifyPhoneNumber(_:uiDelegate:completion:) para solicitar que o Firebase envie um código de autenticação por SMS para o telefone do usuário:
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 usarem login por telefone, poderão receber uma mensagem SMS para verificação e serão aplicadas taxas padrão.
- Chame
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 // ... }Objetivo-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étodoonAppearde uma visualização, o métodoverifyPhoneNumbernã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 do ID de verificação para fazer login do usuário.A mensagem SMS enviada pelo Firebase também pode ser localizada especificando o idioma de autenticação por meio da propriedade
languageCodeem sua instância Auth.Rápido
// Change language code to french. Auth.auth().languageCode = "fr";
Objetivo-C
// Change language code to french. [FIRAuth auth].languageCode = @"fr";
Salve o ID de verificação e restaure-o quando o aplicativo for carregado. Ao fazer isso, você pode garantir que ainda terá um ID de verificação válido se seu aplicativo for encerrado antes que o usuário conclua o fluxo de login (por exemplo, ao mudar para o aplicativo SMS).
Você pode persistir 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")
Objetivo-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")
Objetivo-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 no usuário com o código de verificação
Depois que o usuário fornecer ao aplicativo o código de verificação da mensagem SMS, faça login do usuário criando um objeto FIRPhoneAuthCredential a partir do código de verificação e do ID de verificação e transmitindo esse objeto para signInWithCredential:completion: .
- Obtenha o código de verificação do usuário.
- Crie um objeto
FIRPhoneAuthCredentiala partir do código de verificação e do ID de verificação.Rápido
let credential = PhoneAuthProvider.provider().credential( withVerificationID: verificationID, verificationCode: verificationCode )
Objetivo-C
FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider] credentialWithVerificationID:verificationID verificationCode:userInput]; - 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 // ... }Objetivo-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. Testar com números de telefone fictícios oferece estes benefícios:
- Teste a autenticação do número de telefone sem consumir sua cota de uso.
- Teste a autenticação do número de telefone sem enviar uma mensagem SMS real.
- Execute testes consecutivos com o mesmo número de telefone sem ser limitado. Isso minimiza o risco de rejeição durante o processo de revisão da App Store se o revisor usar o mesmo número de telefone para o teste.
- Teste prontamente em ambientes de desenvolvimento sem nenhum esforço adicional, como a capacidade de desenvolver em um simulador iOS ou em um emulador Android sem o Google Play Services.
- Escreva testes de integração sem ser bloqueado por verificações de segurança normalmente aplicadas em números de telefone reais em um ambiente de produção.
Os números de telefone fictícios devem atender a estes requisitos:
- Certifique-se de usar números de telefone que sejam realmente fictícios e que ainda não existam. O Firebase Authentication não permite definir números de telefone existentes usados por usuários reais como números de teste. Uma opção é usar números prefixados 555 como números de telefone de teste nos EUA, por exemplo: +1 650-555-3434
- Os números de telefone devem ser formatados corretamente quanto ao comprimento e outras restrições. Eles ainda passarão pela mesma validação que o número de telefone de um usuário real.
- Você pode adicionar até 10 números de telefone para desenvolvimento.
- Use números/códigos de telefone de teste que sejam difíceis de adivinhar e altere-os com frequência.
Crie números de telefone e códigos de verificação fictícios
- No console do Firebase , abra a seção Autenticação .
- Na guia Método de login , habilite a operadora de telefonia, caso ainda não o tenha feito.
- Abra o menu acordeão Números de telefone para teste .
- Forneça o número de telefone que deseja testar, por exemplo: +1 650-555-3434 .
- Forneça o código de verificação de 6 dígitos para esse número específico, por exemplo: 654321 .
- Adicione o número. Se houver necessidade, você pode excluir o número de telefone e seu código passando o mouse sobre a linha correspondente e clicando no ícone da lixeira.
Teste manual
Você pode começar a usar diretamente um número de telefone fictício em seu aplicativo. Isso permite que você execute testes manuais durante os estágios de desenvolvimento sem enfrentar problemas de cota ou limitação. Você também pode testar diretamente de um simulador iOS ou emulador Android sem o Google Play Services instalado.
Quando você fornece o número de telefone fictício e envia o código de verificação, nenhum SMS real é enviado. Em vez disso, você precisa fornecer o código de verificação configurado anteriormente para concluir o login.
Após a conclusão do login, um usuário do Firebase é criado com esse número de telefone. O usuário tem o mesmo comportamento e propriedades de um usuário de número de telefone real e pode acessar o Realtime Database/Cloud Firestore e outros serviços da mesma maneira. O token de identificação gerado durante esse processo tem a mesma assinatura de um usuário de número de telefone real.
Outra opção é definir uma função de teste por meio de declarações personalizadas para esses usuários para diferenciá-los como usuários falsos se você quiser restringir ainda mais o acesso.
Teste de integração
Além dos testes manuais, o Firebase Authentication fornece APIs para ajudar a escrever testes de integração para testes de autenticação por telefone. Essas APIs desativam a verificação de aplicativos, desativando o requisito reCAPTCHA na web e notificações push silenciosas no iOS. Isso torna os testes de automação possíveis nesses fluxos e mais fáceis de implementar. Além disso, eles ajudam a fornecer a capacidade de testar fluxos de verificação instantâneos no Android.
No iOS, a configuração appVerificationDisabledForTesting deve ser definida como TRUE antes de chamar verifyPhoneNumber . Isso é processado sem a necessidade de nenhum token APNs ou o envio de 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 estiver desativada, o uso de um número de telefone não fictício não conseguirá concluir o 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
}];
}];Objetivo-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 login por telefone sem swizzling
O Firebase Authentication usa 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 ao seu aplicativo e para interceptar automaticamente o redirecionamento do 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 do Firebase, incluindo o Firebase Cloud Messaging.
Se você desativar o swizzling, deverá transmitir explicitamente o token do dispositivo APNs, as notificações push e o URL de redirecionamento do esquema personalizado para o Firebase Authentication.
Se você estiver criando um aplicativo SwiftUI, também deverá passar explicitamente o token do dispositivo APNs, as notificações push e o URL de redirecionamento do 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 método 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
// ...
}
Objetivo-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 application(_:didReceiveRemoteNotification:fetchCompletionHandler:): verifique se há notificações relacionadas ao Firebase auth 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.
}
Objetivo-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 lidar com o URL de redirecionamento do esquema personalizado, implemente o método application(_:open:options:) e, neles, passe o 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.
}
Objetivo-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 lidar com a URL de redirecionamento, implemente o método scene(_:openURLContexts:) e, neles, passe a URL para o método canHandleURL(_:) do 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.
}
Objetivo-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.
Nos seus aplicativos, você pode obter as informações básicas do perfil do usuário no objeto
User. 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
authe 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: .
Rápido
let firebaseAuth = Auth.auth()
do {
try firebaseAuth.signOut()
} catch let signOutError as NSError {
print("Error signing out: %@", signOutError)
}Objetivo-C
NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
NSLog(@"Error signing out: %@", signOutError);
return;
}Você também pode adicionar código de tratamento de erros para toda a gama de erros de autenticação. Consulte Tratamento de erros .