Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając wiadomość SMS na telefon użytkownika. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w wiadomości SMS.
Najłatwiejszym sposobem dodania logowania za pomocą numeru telefonu do aplikacji jest użycie interfejsu FirebaseUI , który zawiera widżet logowania, który implementuje przepływy logowania na potrzeby logowania za pomocą numeru telefonu, a także podpis oparty na haśle i federacyjny -W. W tym dokumencie opisano, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu Firebase SDK.
Zanim zaczniesz
Użyj Menedżera pakietów Swift, aby zainstalować i zarządzać zależnościami Firebase.
- W Xcode przy otwartym projekcie aplikacji przejdź do File > Add Packages .
- Po wyświetleniu monitu dodaj repozytorium Firebase Apple platforms SDK:
- Wybierz bibliotekę uwierzytelniania Firebase.
- Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.
https://github.com/firebase/firebase-ios-sdk
- Jeśli nie połączyłeś jeszcze swojej aplikacji z projektem Firebase, zrób to z poziomu konsoli Firebase .
Względy bezpieczeństwa
Uwierzytelnianie przy użyciu samego numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenosić między użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik, który może odbierać wiadomości SMS, może zalogować się na konto przy użyciu numeru telefonu urządzenia.
Jeśli korzystasz z logowania za pomocą numeru telefonu w swojej aplikacji, powinieneś oferować je wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach w zakresie bezpieczeństwa związanych z logowaniem za pomocą numeru telefonu.
Włącz logowanie za pomocą numeru telefonu w swoim projekcie Firebase
Aby logować użytkowników za pomocą SMS-ów, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu w swoim projekcie Firebase:
- W konsoli Firebase otwórz sekcję Uwierzytelnianie .
- Na stronie Metoda logowania włącz metodę logowania Numer telefonu .
Limit żądań logowania do numeru telefonu Firebase jest wystarczająco wysoki, aby nie miało to wpływu na większość aplikacji. Jeśli jednak musisz zalogować bardzo dużą liczbę użytkowników za pomocą uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz stronę z cennikiem .
Włącz weryfikację aplikacji
Aby korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi być w stanie zweryfikować, czy żądania logowania za pomocą numeru telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase może to osiągnąć na dwa sposoby:
- Ciche powiadomienia APN : gdy logujesz użytkownika za pomocą jego numeru telefonu po raz pierwszy na urządzeniu, uwierzytelnianie Firebase wysyła token do urządzenia za pomocą cichego powiadomienia push. Jeśli Twoja aplikacja pomyślnie odbierze powiadomienie z Firebase, logowanie za pomocą numeru telefonu może być kontynuowane.
W przypadku systemu iOS 8.0 i nowszych ciche powiadomienia nie wymagają wyraźnej zgody użytkownika i dlatego nie mają na nie wpływu odmowa użytkownika na otrzymywanie powiadomień APN w aplikacji. W związku z tym aplikacja nie musi prosić użytkownika o pozwolenie na otrzymywanie powiadomień push podczas implementacji uwierzytelniania numeru telefonu Firebase.
- Weryfikacja reCAPTCHA : w przypadku, gdy wysłanie lub odebranie cichego powiadomienia push nie jest możliwe, na przykład gdy użytkownik wyłączył odświeżanie w tle dla Twojej aplikacji lub podczas testowania aplikacji na symulatorze iOS, uwierzytelnianie Firebase używa weryfikacji reCAPTCHA, aby ukończyć telefon przepływ logowania. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania czegokolwiek przez użytkownika.
Gdy ciche powiadomienia push są prawidłowo skonfigurowane, tylko bardzo mały procent użytkowników doświadczy przepływu reCAPTCHA. Niemniej jednak należy upewnić się, że logowanie za pomocą numeru telefonu działa poprawnie, niezależnie od tego, czy są dostępne ciche powiadomienia push.
Zacznij otrzymywać ciche powiadomienia
Aby włączyć powiadomienia APN do użytku z uwierzytelnianiem Firebase:
- W Xcode włącz powiadomienia push dla swojego projektu.
Prześlij swój klucz uwierzytelniający APN do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniającego APNs, utwórz go w Apple Developer Member Center .
W swoim projekcie w konsoli Firebase wybierz ikonę koła zębatego, wybierz Ustawienia projektu , a następnie wybierz kartę Cloud Messaging .
W kluczu uwierzytelniania APNs w konfiguracji aplikacji na iOS kliknij przycisk Prześlij .
Przejdź do lokalizacji, w której zapisałeś klucz, wybierz go i kliknij Otwórz . Dodaj identyfikator klucza dla klucza (dostępny w Apple Developer Member Center ) i kliknij Prześlij .
Jeśli masz już certyfikat APNs, możesz zamiast tego przesłać ten certyfikat.
Skonfiguruj weryfikację reCAPTCHA
Aby umożliwić Firebase SDK korzystanie z weryfikacji reCAPTCHA:
- Dodaj niestandardowe schematy adresów URL do swojego projektu Xcode:
- Otwórz konfigurację projektu: kliknij dwukrotnie nazwę projektu w lewym widoku drzewa. Wybierz swoją aplikację z sekcji CELE , następnie wybierz kartę Informacje i rozwiń sekcję Typy adresów URL .
- Kliknij przycisk + i dodaj swój zakodowany identyfikator aplikacji jako schemat adresu URL. Identyfikator zakodowanej aplikacji można znaleźć na stronie Ustawienia ogólne konsoli Firebase, w sekcji dotyczącej aplikacji na iOS. Pozostałe pola pozostaw puste.
Po zakończeniu konfiguracja powinna wyglądać podobnie do poniższej (ale z wartościami specyficznymi dla aplikacji):
- Opcjonalnie : jeśli chcesz dostosować sposób, w jaki aplikacja przedstawia
SFSafariViewControllerpodczas wyświetlania reCAPTCHA użytkownikowi, utwórz niestandardową klasę zgodną z protokołemAuthUIDelegatei przekaż ją doverifyPhoneNumber(_:uiDelegate:completion:).
Wyślij kod weryfikacyjny na telefon użytkownika
Aby zainicjować logowanie za pomocą numeru telefonu, przedstaw użytkownikowi interfejs, który poprosi go o podanie numeru telefonu, a następnie wywołaj funkcję verifyPhoneNumber(_:uiDelegate:completion:) , aby poprosić Firebase o wysłanie SMS-em kodu uwierzytelniającego na telefon użytkownika:
Uzyskaj numer telefonu użytkownika.
Wymagania prawne są różne, ale w ramach najlepszych praktyk i określenia oczekiwań użytkowników należy poinformować ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązują standardowe opłaty.
- Zadzwoń do
verifyPhoneNumber(_:uiDelegate:completion:), przekazując do niej numer telefonu użytkownika.Szybki
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 // ... }Cel 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 // ... }];Metoda
verifyPhoneNumberjest reentrant: jeśli wywołasz ją wiele razy, na przykład w metodzieonAppearwidoku, metodaverifyPhoneNumbernie wyśle drugiego SMS-a, chyba że upłynął limit czasu pierwotnego żądania.Gdy wywołasz
verifyPhoneNumber(_:uiDelegate:completion:), Firebase wyśle do Twojej aplikacji ciche powiadomienie push lub wyśle użytkownikowi wezwanie reCAPTCHA. Gdy Twoja aplikacja otrzyma powiadomienie lub użytkownik ukończy wyzwanie reCAPTCHA, Firebase wyśle wiadomość SMS zawierającą kod uwierzytelniający na podany numer telefonu i przekaże identyfikator weryfikacyjny do funkcji wypełniania. Aby zalogować użytkownika, będziesz potrzebować zarówno kodu weryfikacyjnego, jak i identyfikatora weryfikacyjnego.Wiadomość SMS wysłaną przez Firebase można również zlokalizować, określając język autoryzacji za pomocą właściwości
languageCodew instancji Auth.Szybki
// Change language code to french. Auth.auth().languageCode = "fr";
Cel C
// Change language code to french. [FIRAuth auth].languageCode = @"fr";
Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. W ten sposób możesz mieć pewność, że nadal masz ważny identyfikator weryfikacyjny, jeśli Twoja aplikacja zostanie zamknięta, zanim użytkownik ukończy proces logowania (na przykład podczas przełączania się do aplikacji SMS).
Możesz zachować identyfikator weryfikacyjny w dowolny sposób. Prostym sposobem jest zapisanie identyfikatora weryfikacyjnego z obiektem
NSUserDefaults:Szybki
UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
Cel C
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults]; [defaults setObject:verificationID forKey:@"authVerificationID"];
Następnie możesz przywrócić zapisaną wartość:
Szybki
let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
Cel C
NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
Jeśli wywołanie funkcji verifyPhoneNumber(_:uiDelegate:completion:) zakończy się pomyślnie, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego po otrzymaniu go w wiadomości SMS.
Zaloguj użytkownika za pomocą kodu weryfikacyjnego
Gdy użytkownik dostarczy aplikacji kod weryfikacyjny z wiadomości SMS, zaloguj się, tworząc obiekt FIRPhoneAuthCredential z kodu weryfikacyjnego i identyfikatora weryfikacyjnego i przekazując ten obiekt do signInWithCredential:completion: .
- Uzyskaj kod weryfikacyjny od użytkownika.
- Utwórz obiekt
FIRPhoneAuthCredentialna podstawie kodu weryfikacyjnego i identyfikatora weryfikacyjnego.Szybki
let credential = PhoneAuthProvider.provider().credential( withVerificationID: verificationID, verificationCode: verificationCode )
Cel C
FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider] credentialWithVerificationID:verificationID verificationCode:userInput]; - Zaloguj użytkownika za pomocą obiektu
FIRPhoneAuthCredential:Szybki
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 // ... }Cel 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; // ... }];
Test z fikcyjnymi numerami telefonów
Możesz skonfigurować fikcyjne numery telefonów do programowania za pomocą konsoli Firebase. Testowanie z fikcyjnymi numerami telefonów zapewnia następujące korzyści:
- Przetestuj uwierzytelnianie numeru telefonu bez zużywania limitu użytkowania.
- Przetestuj uwierzytelnianie numeru telefonu bez wysyłania rzeczywistej wiadomości SMS.
- Przeprowadzaj kolejne testy z tym samym numerem telefonu bez ograniczania. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji w App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
- Łatwo testuj w środowiskach programistycznych bez dodatkowego wysiłku, takiego jak możliwość programowania w symulatorze iOS lub emulatorze Androida bez usług Google Play.
- Pisz testy integracyjne bez blokowania przez kontrole bezpieczeństwa, zwykle stosowane na rzeczywistych numerach telefonów w środowisku produkcyjnym.
Fikcyjne numery telefonów muszą spełniać te wymagania:
- Upewnij się, że używasz numerów telefonów, które rzeczywiście są fikcyjne i jeszcze nie istnieją. Uwierzytelnianie Firebase nie pozwala ustawić istniejących numerów telefonów używanych przez prawdziwych użytkowników jako numerów testowych. Jedną z opcji jest użycie numerów z prefiksem 555 jako testowych numerów telefonów w USA, na przykład: +1 650-555-3434
- Numery telefonów muszą być poprawnie sformatowane pod kątem długości i innych ograniczeń. Nadal będą przechodzić tę samą weryfikację, co numer telefonu prawdziwego użytkownika.
- Możesz dodać do 10 numerów telefonów do programowania.
- Używaj testowych numerów telefonów/kodów, które są trudne do odgadnięcia i często je zmieniaj.
Twórz fikcyjne numery telefonów i kody weryfikacyjne
- W konsoli Firebase otwórz sekcję Uwierzytelnianie .
- Na karcie Metoda logowania włącz dostawcę telefonu, jeśli jeszcze tego nie zrobiłeś.
- Otwórz menu Numery telefonów do testowania akordeonu.
- Podaj numer telefonu, który chcesz przetestować, na przykład: +1 650-555-3434 .
- Podaj 6-cyfrowy kod weryfikacyjny dla tego konkretnego numeru, na przykład: 654321 .
- Dodaj numer. W razie potrzeby możesz usunąć numer telefonu i jego kod, najeżdżając kursorem na odpowiedni wiersz i klikając ikonę kosza.
Testowanie ręczne
Możesz od razu zacząć korzystać z fikcyjnego numeru telefonu w swojej aplikacji. Pozwala to na przeprowadzanie testów ręcznych na etapach opracowywania bez problemów z limitami lub ograniczaniem przepustowości. Możesz także testować bezpośrednio z symulatora iOS lub emulatora Androida bez zainstalowanych Usług Google Play.
Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, żaden SMS nie zostanie wysłany. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby dokończyć logowanie.
Po zakończeniu logowania tworzony jest użytkownik Firebase z tym numerem telefonu. Użytkownik ma takie same zachowanie i właściwości jak prawdziwy użytkownik numeru telefonu i może uzyskiwać dostęp do bazy danych czasu rzeczywistego/Cloud Firestore i innych usług w ten sam sposób. Token identyfikacyjny wybity podczas tego procesu ma taki sam podpis jak prawdziwy użytkownik numeru telefonu.
Inną opcją jest ustawienie roli testowej za pomocą niestandardowych oświadczeń dla tych użytkowników, aby odróżnić ich jako fałszywych użytkowników, jeśli chcesz dodatkowo ograniczyć dostęp.
Testy integracyjne
Oprócz testów ręcznych usługa Firebase Authentication udostępnia interfejsy API ułatwiające pisanie testów integracyjnych na potrzeby testowania uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w sieciowych i cichych powiadomieniach push w iOS. Dzięki temu testowanie automatyzacji jest możliwe w tych przepływach i łatwiejsze do wdrożenia. Ponadto pomagają zapewnić możliwość testowania przepływów natychmiastowej weryfikacji na Androidzie.
W systemie iOS ustawienie appVerificationDisabledForTesting musi być ustawione na TRUE przed wywołaniem verifyPhoneNumber . Jest to przetwarzane bez konieczności używania tokena APN lub wysyłania cichych powiadomień push w tle, co ułatwia testowanie w symulatorze. Spowoduje to również wyłączenie przepływu awaryjnego reCAPTCHA.
Pamiętaj, że gdy weryfikacja aplikacji jest wyłączona, logowanie przy użyciu niefikcyjnego numeru telefonu nie powiedzie się. Z tym interfejsem API można używać tylko fikcyjnych numerów telefonów.
Szybki
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
}];
}];Cel 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;
}];
}];Dodatek: Korzystanie z logowania przez telefon bez zmiany
Uwierzytelnianie Firebase używa metody swizzling do automatycznego uzyskiwania tokena APN Twojej aplikacji, obsługi cichych powiadomień push, które Firebase wysyła do Twojej aplikacji, oraz automatycznego przechwytywania niestandardowego schematu przekierowania ze strony weryfikacji reCAPTCHA podczas weryfikacji.
Jeśli wolisz nie używać swizzlingu, możesz go wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled do pliku Info.plist aplikacji i ustawiając ją na NO . Pamiętaj, że ustawienie tej flagi na NO wyłącza również funkcję swizzling dla innych produktów Firebase, w tym Firebase Cloud Messaging.
Jeśli wyłączysz swizzling, musisz jawnie przekazać token urządzenia APNs, powiadomienia push i niestandardowy adres URL przekierowania schematu do uwierzytelniania Firebase.
Jeśli tworzysz aplikację SwiftUI, powinieneś również jawnie przekazać token urządzenia APNs, powiadomienia push i niestandardowy adres URL przekierowania schematu do uwierzytelniania Firebase.
Aby uzyskać token urządzenia APNs, zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:) i w niej przekaż token urządzenia do metody setAPNSToken(_:type:) Auth .
Szybki
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
// ...
}
Cel 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.
}
Aby obsłużyć powiadomienia push, w application(_:didReceiveRemoteNotification:fetchCompletionHandler:): sprawdź powiadomienia związane z uwierzytelnianiem Firebase, wywołując metodę canHandleNotification(_:) Auth .
Szybki
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.
}
Cel 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.
}
Aby obsłużyć adres URL przekierowania niestandardowego schematu, zaimplementuj metodę application(_:open:options:) i w nich przekaż adres URL do metody canHandleURL(_:) Auth .
Szybki
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.
}
Cel 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.
}
Jeśli używasz SwiftUI lub UISceneDelegate , aby obsłużyć adres URL przekierowania, zaimplementuj metodę scene(_:openURLContexts:) i w nich przekaż adres URL do metody canHandleURL(_:) Auth .
Szybki
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.
}
Cel 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.
}
}
Następne kroki
Gdy użytkownik zaloguje się po raz pierwszy, tworzone jest nowe konto użytkownika, które jest łączone z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — za pomocą których użytkownik się logował. To nowe konto jest przechowywane jako część Twojego projektu Firebase i może służyć do identyfikacji użytkownika w każdej aplikacji w Twoim projekcie, niezależnie od tego, jak użytkownik się loguje.
W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu
User. Zobacz Zarządzanie użytkownikami .W regułach bezpieczeństwa Firebase Realtime Database i Cloud Storage możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej
authi użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.
Możesz zezwolić użytkownikom na logowanie się do Twojej aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.
Aby wylogować użytkownika, wywołaj funkcję signOut: .
Szybki
let firebaseAuth = Auth.auth()
do {
try firebaseAuth.signOut()
} catch let signOutError as NSError {
print("Error signing out: %@", signOutError)
}Cel C
NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
NSLog(@"Error signing out: %@", signOutError);
return;
}Możesz także dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Zobacz Obsługa błędów .