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 FirebaseUI , który zawiera widżet logowania, który implementuje przepływy logowania na potrzeby logowania się za pomocą numeru telefonu, a także logowanie oparte na hasłach i federacyjne -W. W tym dokumencie opisano, jak zaimplementować proces logowania się za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.
Zanim zaczniesz
Użyj Menedżera pakietów Swift, aby zainstalować zależności Firebase i zarządzać nimi.
- W Xcode, przy otwartym projekcie aplikacji, przejdź do File > Add Packages .
- Po wyświetleniu monitu dodaj repozytorium SDK platform Firebase Apple:
- Wybierz bibliotekę uwierzytelniania Firebase.
- Dodaj flagę
-ObjCdo sekcji Inne flagi linkera w ustawieniach kompilacji celu. - Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.
https://github.com/firebase/firebase-ios-sdk.git
- Jeśli jeszcze nie połączyłeś aplikacji z projektem Firebase, zrób to z konsoli Firebase .
Obawy dotyczące 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ć pomiędzy użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik mogący odbierać wiadomości SMS może zalogować się na konto przy użyciu numeru telefonu urządzenia.
Jeśli w swojej aplikacji używasz logowania przy użyciu numeru telefonu, powinieneś zaoferować tę opcję obok bezpieczniejszych metod logowania i poinformować użytkowników o kompromisach w zakresie bezpieczeństwa, jakie wiążą się z logowaniem się za pomocą numeru telefonu.
Włącz logowanie za pomocą numeru telefonu w swoim projekcie Firebase
Aby logować użytkowników za pomocą wiadomości SMS, 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 za pomocą numeru telefonu .
Limit żądań logowania na numer telefonu w Firebase jest na tyle wysoki, że nie będzie to miało wpływu na większość aplikacji. Jeśli jednak chcesz zalogować bardzo dużą liczbę użytkowników przy użyciu uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz stronę z cenami .
Włącz weryfikację aplikacji
Aby móc korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy prośby o zalogowanie się na numer telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase realizuje to na dwa sposoby:
- Ciche powiadomienia APN : gdy po raz pierwszy logujesz się na urządzeniu za pomocą numeru telefonu, funkcja uwierzytelniania Firebase wysyła token do urządzenia za pomocą cichego powiadomienia push. Jeśli Twoja aplikacja pomyślnie odbierze powiadomienie z Firebase, będzie można kontynuować logowanie na numer telefonu.
W przypadku systemu iOS 8.0 i nowszych ciche powiadomienia nie wymagają wyraźnej zgody użytkownika i dlatego nie ma na nie wpływu odmowa przez użytkownika otrzymywania powiadomień APN w aplikacji. Dlatego aplikacja nie musi pytać użytkownika o pozwolenie na otrzymywanie powiadomień push podczas wdrażania 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 wykorzystuje weryfikację reCAPTCHA do zakończenia połączenia telefonicznego przepływ logowania. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania przez użytkownika czegokolwiek.
Jeśli ciche powiadomienia push są prawidłowo skonfigurowane, tylko niewielki procent użytkowników doświadczy przepływu reCAPTCHA. Niemniej jednak należy upewnić się, że logowanie za pomocą numeru telefonu działa prawidłowo, niezależnie od tego, czy dostępne są 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 APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniającego APNs, pamiętaj o utworzeniu go w Apple Developer Member Center .
Wewnątrz projektu w konsoli Firebase wybierz ikonę koła zębatego, wybierz Ustawienia projektu , a następnie wybierz kartę Cloud Messaging .
W kluczu uwierzytelniania APN w obszarze konfiguracji aplikacji na iOS kliknij przycisk Prześlij .
Przejdź do lokalizacji, w której zapisałeś klucz, wybierz ją i kliknij Otwórz . Dodaj identyfikator klucza (dostępny w Apple Developer Member Center ) i kliknij Prześlij .
Jeśli masz już certyfikat APNs, możesz zamiast tego przesłać go.
Skonfiguruj weryfikację reCAPTCHA
Aby umożliwić pakietowi SDK Firebase 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ę w sekcji CELE , następnie wybierz kartę Informacje i rozwiń sekcję Typy adresów URL .
- Kliknij przycisk + i dodaj zakodowany identyfikator aplikacji jako schemat adresu URL. Zakodowany identyfikator aplikacji znajdziesz na stronie Ustawienia ogólne konsoli Firebase, w sekcji 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 prezentuje
SFSafariViewControllerpodczas wyświetlania użytkownikowi reCAPTCHA, utwórz klasę niestandardową zgodną z protokołemAuthUIDelegatei przekaż ją doverifyPhoneNumber(_:uiDelegate:completion:).
Wyślij kod weryfikacyjny na telefon użytkownika
Aby zainicjować logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs, który poprosi go o podanie numeru telefonu, a następnie wywołaj verifyPhoneNumber(_:uiDelegate:completion:) , aby poprosić Firebase o przesłanie kodu uwierzytelniającego na telefon użytkownika za pomocą wiadomości SMS:
Uzyskaj numer telefonu użytkownika.
Wymagania prawne są różne, ale w ramach najlepszej praktyki i w celu ustalenia oczekiwań użytkowników należy poinformować ich, że w przypadku korzystania z logowania przez telefon mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązywać będą standardowe stawki.
- Wywołaj funkcję
verifyPhoneNumber(_:uiDelegate:completion:), przekazując jej 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 metodą współbieżną: jeśli wywołasz ją wiele razy, na przykład w metodzieonAppearwidoku, metodaverifyPhoneNumbernie wyśle drugiej wiadomości SMS, chyba że upłynął limit czasu pierwotnego żądania.Kiedy wywołujesz
verifyPhoneNumber(_:uiDelegate:completion:), Firebase wysyła ciche powiadomienie push do Twojej aplikacji lub wysyła do użytkownika wezwanie reCAPTCHA. Gdy Twoja aplikacja otrzyma powiadomienie lub użytkownik zakończy wyzwanie reCAPTCHA, Firebase wysyła wiadomość SMS zawierającą kod uwierzytelniający na podany numer telefonu i przekazuje identyfikator weryfikacyjny do funkcji zakończenia. 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 uwierzytelniania 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 aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (na przykład podczas przełączania się do aplikacji do obsługi SMS-ów).
Możesz zachować identyfikator weryfikacyjny w dowolny sposób. Prostym sposobem jest zapisanie identyfikatora weryfikacji za pomocą obiektu
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:) powiedzie się, 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 poda aplikacji kod weryfikacyjny z wiadomości SMS, zaloguj się, tworząc obiekt FIRPhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacyjnego, a następnie 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; // ... }];
Przetestuj 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 wykorzystania.
- Przetestuj uwierzytelnianie numeru telefonu bez wysyłania wiadomości SMS.
- Przeprowadzaj kolejne testy z tym samym numerem telefonu, nie ulegając ograniczeniom. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji w App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
- Możliwość łatwego testowania 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 w przypadku rzeczywistych numerów 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 na ustawienie 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 555 z prefiksem 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 celów rozwoju.
- 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 opcję Dostawca 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. Jeśli zajdzie taka potrzeba, 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ąć używać fikcyjnego numeru telefonu w swojej aplikacji. Umożliwia to przeprowadzanie testów ręcznych na etapach programowania bez problemów z przydziałami i 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, żadna wiadomość SMS nie zostanie wysłana. 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 właściwości i zachowanie jak użytkownik prawdziwego numeru telefonu i może uzyskać dostęp do bazy danych Realtime/Cloud Firestore i innych usług w ten sam sposób. Token identyfikacyjny wybity podczas tego procesu ma taki sam podpis, jak użytkownik prawdziwego numeru telefonu.
Inną opcją jest ustawienie roli testowej za pomocą niestandardowych oświadczeń dla tych użytkowników, aby odróżnić ich od fałszywych użytkowników, jeśli chcesz jeszcze bardziej ograniczyć dostęp.
Testy integracyjne
Oprócz testów ręcznych, uwierzytelnianie Firebase udostępnia interfejsy API, które pomagają pisać testy integracyjne na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w powiadomieniach internetowych i cichych powiadomieniach push w systemie iOS. Dzięki temu możliwe jest testowanie automatyczne w tych przepływach i łatwiejsze do wdrożenia. Ponadto pomagają zapewnić możliwość testowania natychmiastowych procesów weryfikacji na Androidzie.
W systemie iOS ustawienie appVerificationDisabledForTesting musi mieć wartość TRUE przed wywołaniem verifyPhoneNumber . Jest to przetwarzane bez konieczności stosowania tokena APN lub wysyłania cichych powiadomień push w tle, co ułatwia testowanie w symulatorze. Wyłącza to również przepływ awaryjny reCAPTCHA.
Pamiętaj, że jeśli weryfikacja aplikacji jest wyłączona, użycie niefikcyjnego numeru telefonu nie umożliwi dokończenia logowania. W tym interfejsie API można używać wyłącznie 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 za pomocą telefonu bez konieczności przełączania
Uwierzytelnianie Firebase wykorzystuje metodę swizzling, aby automatycznie uzyskać token APNs Twojej aplikacji, obsługiwać ciche powiadomienia push wysyłane przez Firebase do Twojej aplikacji i automatycznie przechwytywać przekierowanie niestandardowego schematu ze strony weryfikacji reCAPTCHA podczas weryfikacji.
Jeśli nie chcesz używać swizzlingu, możesz go wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled do pliku Info.plist aplikacji i ustawiając ją na NO . Należy pamiętać, że ustawienie tej flagi na NO powoduje również wyłączenie przełączania 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 adres URL przekierowania schematu niestandardowego do uwierzytelniania Firebase.
Jeśli tworzysz aplikację SwiftUI, powinieneś również jawnie przekazać token urządzenia APNs, powiadomienia push i adres URL przekierowania schematu niestandardowego do uwierzytelniania Firebase.
Aby uzyskać token urządzenia APNs należy zaimplementować metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:) i w niej przekazać 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ć niestandardowy adres URL przekierowania 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 , do obsługi adresu 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, zostanie utworzone nowe konto użytkownika i powiązane z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — za pomocą których użytkownik się zalogował. To nowe konto jest przechowywane jako część Twojego projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w Twoim projekcie, niezależnie od tego, w jaki sposób użytkownik się loguje.
W Twoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu
User. Zobacz Zarządzanie użytkownikami .W regułach bezpieczeństwa bazy danych Firebase Realtime i Cloud Storage możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej
authi użyć go do kontrolowania, do jakich danych użytkownik może uzyskać dostęp.
Możesz zezwolić użytkownikom na logowanie się do 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 Błędy obsługi .