Możesz używać uwierzytelniania Firebase do logowania użytkownika, wysyłając SMS-a na jego telefon. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w wiadomości SMS.
Najprostszym sposobem na dodanie do aplikacji logowania za pomocą numeru telefonu jest użycie w FirebaseUI, czyli widżetu logowania, który implementuje procesy logowania za pomocą numeru telefonu, a także logowanie oparte na haśle i logowanie sfederowane. W tym dokumencie opisujemy, jak za pomocą pakietu SDK Firebase wdrożyć proces logowania się numerem telefonu.
Zanim zaczniesz
- Jeśli Twoja aplikacja nie jest jeszcze połączona z projektem Firebase, możesz to zrobić z poziomu konsoli Firebase.
-
Użyj menedżera pakietów Swift, aby zainstalować zależności Firebase i nimi zarządzać.
- Po otwarciu projektu aplikacji przejdź w Xcode do File > Add Packages (Plik > Dodaj pakiety).
- Gdy pojawi się prośba, dodaj repozytorium SDK platform Apple Platform SDK Firebase:
- Wybierz bibliotekę uwierzytelniania Firebase.
- Dodaj flagę
-ObjCdo sekcji Inne flagi łączące w ustawieniach kompilacji celu. - Po zakończeniu Xcode automatycznie rozpocznie rozpoznawanie i pobieranie zależności w tle.
https://github.com/firebase/firebase-ios-sdk.git
Potencjalne problemy z bezpieczeństwem
Uwierzytelnianie przy użyciu numeru telefonu, choć jest wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenieść między użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkownika każdy użytkownik, który może odbierać SMS-y, może zalogować się na konto przy użyciu numeru telefonu tego urządzenia.
Jeśli w swojej aplikacji korzystasz z logowania się na podstawie numeru telefonu, zaoferuj je wraz z bezpieczniejszymi metodami logowania i poinformuj użytkowników o problemach związanych z bezpieczeństwem logowania się przy użyciu numeru telefonu.
Włączanie logowania się za pomocą numeru telefonu w projekcie Firebase
Aby logować użytkowników SMS-em, musisz najpierw włączyć w projekcie Firebase metodę logowania z numerem telefonu:
- W konsoli Firebase otwórz sekcję Uwierzytelnianie.
- Na stronie Metoda logowania włącz metodę logowania Numer telefonu.
Limit próśb Firebase o zalogowanie się za pomocą numeru telefonu jest tak wysoki, że nie będzie to miało wpływu na większość aplikacji. Jeśli jednak musisz zalogować bardzo dużą liczbę użytkowników z wykorzystaniem uwierzytelniania przez telefon, konieczne może być przejście na wyższy abonament. Zobacz stronę z cenami.
Włącz weryfikację aplikacji
Aby używać uwierzytelniania przez numer telefonu, Firebase musi mieć możliwość weryfikacji, czy żądania logowania na numer telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase umożliwia to na 2 sposoby:
- Ciche powiadomienia APNs: gdy po raz pierwszy logujesz użytkownika na urządzeniu za pomocą jego numeru telefonu, Uwierzytelnianie Firebase wysyła do urządzenia token za pomocą cichego powiadomienia push. Jeśli Twoja aplikacja otrzyma powiadomienie z Firebase, będzie można logować się przy użyciu numeru telefonu.
W systemie iOS 8.0 lub nowszym ciche powiadomienia nie wymagają wyraźnej zgody użytkownika i nie mają na nie wpływu, gdy użytkownik nie chce otrzymywać powiadomień APNs w aplikacji. Dzięki temu aplikacja nie musi prosić użytkownika o zgodę na otrzymywanie powiadomień push podczas wdrażania uwierzytelniania numeru telefonu w Firebase.
- Weryfikacja za pomocą reCAPTCHA: jeśli nie jest możliwe wysyłanie lub odbieranie cichych powiadomień push, np. gdy użytkownik wyłączył odświeżanie w tle dla aplikacji lub testujesz aplikację w symulatorze iOS, Uwierzytelnianie Firebase używa weryfikacji reCAPTCHA do ukończenia procesu logowania telefonu. Zadanie reCAPTCHA często można wykonać bez konieczności rozwiązywania żadnych problemów przez użytkownika.
Gdy ciche powiadomienia push zostaną prawidłowo skonfigurowane, tylko niewielki odsetek użytkowników będzie mieć kontakt z procesem reCAPTCHA. Musisz jednak sprawdzić, czy logowanie z użyciem numeru telefonu działa poprawnie, niezależnie od tego, czy są dostępne ciche powiadomienia push.
Zacznij otrzymywać ciche powiadomienia
Aby włączyć powiadomienia APNs do użytku z Uwierzytelnianiem Firebase:
- W Xcode włącz powiadomienia push dla swojego projektu.
-
Prześlij swój klucz uwierzytelniania APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APNs, utwórz go w Apple Developer Member Center.
-
W projekcie w konsoli Firebase kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie kartę Komunikacja w chmurze.
-
W sekcji Klucz uwierzytelniania APNs w sekcji Konfiguracja aplikacji na iOS kliknij przycisk Prześlij.
-
Przejdź do lokalizacji, w której masz zapisany klucz, wybierz go 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 go przesłać.
-
Skonfiguruj weryfikację reCAPTCHA
Aby włączyć weryfikację reCAPTCHA w pakiecie SDK Firebase:
- Dodaj niestandardowe schematy adresów URL do projektu Xcode:
- Otwórz konfigurację projektu: kliknij dwukrotnie nazwę projektu w widoku drzewa po lewej stronie. Wybierz aplikację w sekcji CELE, kliknij 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 dotyczącej aplikacji na iOS. Pozostałe pola pozostaw puste.
Po zakończeniu konfiguracja powinna wyglądać podobnie do tej (ale z wartościami dotyczącymi 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ąverifyPhoneNumber(_:uiDelegate:completion:).
Wysyłanie kodu weryfikacyjnego na telefon użytkownika
Aby rozpocząć logowanie za pomocą numeru telefonu, użyj interfejsu z prośbą o podanie numeru telefonu, a następnie zadzwoń pod numer verifyPhoneNumber(_:uiDelegate:completion:), aby poprosić Firebase o wysłanie SMS-a z kodem uwierzytelniającym na telefon użytkownika:
-
Uzyskaj numer telefonu użytkownika.
Wymagania prawne są różne, ale zgodnie ze sprawdzoną metodą oraz ustaleniem oczekiwań użytkowników należy poinformować ich, że jeśli logują się przez telefon, mogą otrzymać SMS-a w celu weryfikacji. Obowiązują opłaty standardowe.
- Zadzwoń pod numer
verifyPhoneNumber(_:uiDelegate:completion:)i przekaż mu numer telefonu użytkownika.Swift
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 // ... }];Metoda
verifyPhoneNumberjest wielokrotnie wywoływana, np. w metodzieonAppearwidoku, metodaverifyPhoneNumbernie wyśle drugiego SMS-a, chyba że upłynie limit czasu pierwotnego żądania.Gdy wywołujesz
verifyPhoneNumber(_:uiDelegate:completion:), Firebase wysyła do Twojej aplikacji ciche powiadomienie push lub wysyła użytkownikowi test reCAPTCHA. Gdy Twoja aplikacja otrzyma powiadomienie lub użytkownik ukończy test reCAPTCHA, Firebase wyśle na podany numer telefonu SMS-a z kodem uwierzytelniającym i przekaże identyfikator weryfikacyjny do funkcji uzupełniania. Aby zalogować użytkownika, musisz podać zarówno kod weryfikacyjny, jak i identyfikator weryfikacyjny.SMS wysłany przez Firebase można również zlokalizować, określając język uwierzytelniania za pomocą właściwości
languageCodew wystąpieniu Auth.Swift
// Change language code to french. Auth.auth().languageCode = "fr";
Objective-C
// Change language code to french. [FIRAuth auth].languageCode = @"fr";
-
Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. Dzięki temu będziesz mieć pewność, że nadal będziesz mieć ważny identyfikator weryfikacyjny, jeśli Twoja aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (na przykład podczas przełączania się do aplikacji do SMS-ów).
Identyfikator weryfikacyjny możesz zachować w dowolny sposób. Aby w prosty sposób zapisać identyfikator weryfikacji w obiekcie
NSUserDefaults:Swift
UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
Objective-C
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults]; [defaults setObject:verificationID forKey:@"authVerificationID"];
Następnie możesz przywrócić zapisaną wartość:
Swift
let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
Objective-C
NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
Po nawiązaniu połączenia z numerem verifyPhoneNumber(_:uiDelegate:completion:) możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w SMS-ie.
Logowanie użytkownika za pomocą kodu weryfikacyjnego
Gdy użytkownik poda Twojej aplikacji kod weryfikacyjny z SMS-a, zaloguj go, tworząc obiekt FIRPhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacji, a następnie przekazując go do signInWithCredential:completion:.
- Uzyskaj kod weryfikacyjny od użytkownika.
- Utwórz obiekt
FIRPhoneAuthCredentialna podstawie kodu weryfikacyjnego i identyfikatora weryfikacji.Swift
let credential = PhoneAuthProvider.provider().credential( withVerificationID: verificationID, verificationCode: verificationCode )
Objective-C
FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider] credentialWithVerificationID:verificationID verificationCode:userInput]; - Zaloguj użytkownika za pomocą obiektu
FIRPhoneAuthCredential:Swift
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; // ... }];
Testowanie za pomocą fikcyjnych numerów telefonów
W konsoli Firebase możesz skonfigurować fikcyjne numery telefonów na potrzeby programowania. Testowanie fikcyjnych numerów telefonu daje następujące korzyści:
- Przetestuj uwierzytelnianie za pomocą numeru telefonu bez przekraczania limitu wykorzystania.
- Przetestuj uwierzytelnianie numeru telefonu bez wysyłania faktycznego SMS-a.
- Przeprowadzaj kolejne testy z tym samym numerem telefonu bez ograniczania limitu. Pozwala to zminimalizować ryzyko odrzucenia podczas procesu sprawdzania w sklepie z aplikacjami, jeśli weryfikator użyje do testów tego samego numeru telefonu.
- Możesz łatwo przeprowadzać testy w środowiskach programistycznych bez żadnych dodatkowych czynności, takich jak możliwość tworzenia aplikacji w symulatorze iOS lub w emulatorze Androida bez Usług Google Play.
- Pisz testy integracji bez blokowania przez testy zabezpieczeń, które zwykle stosują się do prawdziwych numerów telefonów w środowisku produkcyjnym.
Fikcyjne numery telefonów muszą spełniać te wymagania:
- Upewnij się, że używane numery telefonów są fałszywe i nie istnieją. Uwierzytelnianie Firebase nie umożliwia ustawiania istniejących numerów telefonów używanych przez prawdziwych użytkowników jako numerów testowych. Jedną z opcji jest użycie 555 numerów z prefiksem w amerykańskich testowych numerach telefonów, na przykład: +1 650-555-3434
- Numery telefonów muszą być poprawnie sformatowane pod kątem długości i innych ograniczeń. Nadal przechodzą one taką samą weryfikację jak numer telefonu rzeczywistego użytkownika.
- Możesz dodać maksymalnie 10 numerów telefonów na potrzeby programowania.
- Używaj testowych numerów telefonów lub kodów, które trudno odgadnąć, i często je zmieniaj.
Tworzenie fikcyjnych numerów telefonów i kodów weryfikacyjnych
- W konsoli Firebase otwórz sekcję Uwierzytelnianie.
- Na karcie Metoda logowania włącz dostawcę telefonu, jeśli nie jest jeszcze włączony.
- Otwórz menu nawigacyjne Numery telefonów do testowania.
- Podaj numer telefonu, który chcesz przetestować, np. +1 650-555-3434.
- Podaj 6-cyfrowy kod weryfikacyjny tego numeru, np. 654321.
- Dodaj numer. W razie potrzeby możesz usunąć numer telefonu i jego kod. Aby to zrobić, najedź kursorem na odpowiedni wiersz i kliknij ikonę kosza.
Testy ręczne
Możesz od razu zacząć używać fikcyjnego numeru telefonu we wniosku. Dzięki temu możesz przeprowadzać testy ręczne na etapach programowania, nie powodując problemów z limitami ani ich ograniczania. Możesz też przeprowadzać testy bezpośrednio za pomocą symulatora iOS lub emulatora Androida bez zainstalowanych Usług Google Play.
Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, SMS nie zostanie wysłany. Zamiast tego, aby dokończyć logowanie, musisz podać wcześniej skonfigurowany kod weryfikacyjny.
Gdy się zalogujesz, zostanie utworzony użytkownik Firebase z tym numerem telefonu. Działa on tak samo i ma takie same właściwości jak prawdziwy użytkownik numeru telefonu. W ten sam sposób może również korzystać z Bazy danych czasu rzeczywistego/Cloud Firestore oraz innych usług. Token tożsamości wygenerowany podczas tego procesu ma taki sam podpis jak prawdziwy użytkownik numeru telefonu.
Możesz też ustawić rolę testową dla tych użytkowników za pomocą roszczeń niestandardowych, aby odróżnić ich jako fałszywych użytkowników, jeśli chcesz jeszcze bardziej ograniczyć dostęp do nich.
Testowanie integracji
Oprócz testowania ręcznego Uwierzytelnianie Firebase udostępnia interfejsy API, które ułatwiają pisanie testów integracji na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji przez wyłączenie wymogu reCAPTCHA w internecie oraz cichych powiadomień push na urządzeniach z iOS. Dzięki temu możliwe jest testowanie automatyzacji w tych procesach i łatwiejsze ich wdrożenie. Rozwiązanie pozwala też testować procesy błyskawicznej weryfikacji na Androidzie.
W iOS ustawienie appVerificationDisabledForTesting musi być ustawione na TRUE, zanim wywołasz verifyPhoneNumber. Proces ten jest przetwarzany bez konieczności wymagania tokena APNs ani wysyłania dyskretnych powiadomień push w tle, co ułatwia testowanie w symulatorze. Spowoduje to również wyłączenie przepływu kreacji zastępczej reCAPTCHA.
Pamiętaj, że po wyłączeniu weryfikacji aplikacji nie uda Ci się zalogować za pomocą fikcyjnego numeru telefonu. Za pomocą tego interfejsu API można używać tylko fikcyjnych numerów telefonów.
Swift
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;
}];
}];
Dodatek: logowanie się telefonem bez przesuwania palcem
Uwierzytelnianie Firebase używa metody swizzling, aby automatycznie uzyskiwać token APN Twojej aplikacji, obsługiwać ciche powiadomienia push wysyłane do aplikacji i automatycznie przechwytywać przekierowanie schematu niestandardowego ze strony weryfikacji reCAPTCHA podczas weryfikacji.
Jeśli nie chcesz używać przesuwania, możesz je 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ż przesuwanie w innych usługach Firebase, w tym w Komunikacji w chmurze Firebase.
Jeśli wyłączysz swizzing, musisz jawnie przekazać token urządzenia APNs, powiadomienia push i niestandardowy adres URL przekierowania schematu do uwierzytelniania Firebase.
Jeśli tworzysz aplikację SwiftUI, musisz też jawnie przekazać do uwierzytelniania Firebase token urządzenia APNs, powiadomienia push i niestandardowy adres URL przekierowania schematu.
Aby uzyskać token urządzenia APNs, zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:) i przekaż w niej token urządzenia do metody setAPNSToken(_:type:) Auth.
Swift
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.
}
Aby obsługiwać powiadomienia push, w metodzie application(_:didReceiveRemoteNotification:fetchCompletionHandler:): sprawdź powiadomienia związane z uwierzytelnianiem Firebase, wywołując metodę canHandleNotification(_:) usługi Auth.
Swift
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.
}
Aby obsługiwać przekierowanie schematu niestandardowego, zaimplementuj metodę application(_:open:options:) i przekaż adres URL do metody canHandleURL(_:) metody Auth.
Swift
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.
}
Jeśli używasz SwiftUI lub UISceneDelegate do obsługi adresu URL przekierowania, zaimplementuj metodę scene(_:openURLContexts:), a w niej przekaż adres URL do metody Auth canHandleURL(_:).
Swift
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.
}
}
Dalsze kroki
Gdy użytkownik loguje się po raz pierwszy, tworzone jest nowe konto użytkownika, które jest łączone z danymi logowania (nazwa użytkownika i hasło, numer telefonu lub informacje o dostawcy uwierzytelniania). Nowe konto jest przechowywane w ramach Twojego projektu Firebase i może być używane do identyfikowania użytkowników we wszystkich aplikacjach w Twoim projekcie niezależnie od tego, jak się on loguje.
-
W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu
User. Zobacz Zarządzanie użytkownikami. W regułach zabezpieczeń Bazy danych czasu rzeczywistego Firebase i Cloud Storage możesz pobrać ze zmiennej
authunikalny identyfikator użytkownika zalogowanego użytkownika i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.
Możesz zezwolić użytkownikom na logowanie się w aplikacji przy użyciu różnych dostawców uwierzytelniania, łącząc dane logowania dostawcy uwierzytelniania z istniejącym kontem użytkownika.
Aby wylogować użytkownika, wywołaj
signOut:.
Swift
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;
}
Możesz też dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Patrz sekcja Obsługa błędów.