Uwierzytelnianie w Firebase na platformach Apple przy użyciu numeru telefonu

Możesz użyć Firebase Authentication, aby zalogować użytkownika, wysyłając SMS-a na jego telefon. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w SMS-ie.

Najprostszym sposobem dodania logowania za pomocą numeru telefonu do aplikacji jest użycie FirebaseUI, które zawiera gotowy widget logowania, który wdraża przepływy logowania za pomocą numeru telefonu, a także logowania za pomocą hasła i logowania sfederowanego. W tym dokumencie opisujemy, jak za pomocą pakietu SDK Firebase wdrożyć proces logowania za pomocą numeru telefonu.

Zanim zaczniesz

  1. Jeśli nie masz jeszcze połączonej aplikacji z projektem Firebase, zrób to w konsoli Firebase.

  2. Do instalacji zależności Firebase i zarządzania nimi możesz używać menedżera pakietów Swift.

    1. Po otwarciu projektu aplikacji w Xcode wybierz Plik > Dodaj pakiety.
    2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK Firebase na platformy Apple:
      3.   https://github.com/firebase/firebase-ios-sdk.git
    3. Wybierz bibliotekę Firebase Authentication.
    4. Dodaj flagę -ObjC do sekcji Inne flagi linkera w ustawieniach kompilacji docelowej.
    5. Gdy to zrobisz, Xcode automatycznie zacznie wyszukiwać i pobierać zależności w tle.

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie za pomocą tylko numeru telefonu jest wygodne, ale mniej bezpieczne niż inne dostępne metody, ponieważ numer telefonu można łatwo przekazać innemu użytkownikowi. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik, który może odbierać SMS-y, może zalogować się na konto za pomocą numeru telefonu urządzenia.

Jeśli w aplikacji używasz logowania na podstawie numeru telefonu, powinnaś je oferować razem z bardziej bezpiecznymi metodami logowania i informować użytkowników o konsekwencjach zabezpieczeń związanych z logowaniem na podstawie numeru telefonu.

Włączanie logowania za pomocą numeru telefonu w projekcie Firebase

Aby umożliwić użytkownikom logowanie się za pomocą SMS-a, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu w projekcie Firebase:

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  2. Na stronie Metoda logowania włącz metodę logowania Numer telefonu.

Włączanie weryfikacji aplikacji

Aby korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy żądania logowania się za pomocą numeru telefonu pochodzą z Twojej aplikacji. Firebase Authentication może to zrobić na 2 sposoby:

  • Ciche powiadomienia APN: gdy po raz pierwszy logujesz użytkownika za pomocą jego numeru telefonu na urządzeniu, Firebase Authentication wysyła token na urządzenie za pomocą cichego powiadomienia push. Jeśli Twoja aplikacja otrzyma powiadomienie z Firebase, możesz przejść do logowania za pomocą numeru telefonu.

    W przypadku systemu iOS 8.0 i nowszych powiadomienia bez dźwięku nie wymagają wyraźnej zgody użytkownika, więc nie ma znaczenia, czy użytkownik odmówił otrzymywania powiadomień APN w aplikacji. Aplikacja nie musi więc prosić o zgodę na otrzymywanie powiadomień push podczas implementowania uwierzytelniania numeru telefonu w Firebase.

  • Weryfikacja reCAPTCHA: jeśli wysyłanie lub odbieranie powiadomień push w trybie cichym jest niemożliwe, np. gdy użytkownik wyłączył odświeżanie w tle w aplikacji lub gdy testuje aplikację na symulatorze iOS, Firebase Authentication używa weryfikacji reCAPTCHA do ukończenia procesu logowania na telefonie. Wyzwanie reCAPTCHA można często wykonać bez konieczności rozwiązywania zadań przez użytkownika.

Gdy ciche powiadomienia push są prawidłowo skonfigurowane, tylko bardzo mały odsetek użytkowników będzie korzystał z przepływu reCAPTCHA. Mimo to musisz się upewnić, że logowanie za pomocą numeru telefonu działa prawidłowo niezależnie od tego, czy dostępne są powiadomienia push bez dźwięku.

Zacznij otrzymywać wyciszone powiadomienia

Aby włączyć powiadomienia APN do użycia z Firebase Authentication:

  1. W Xcode włącz powiadomienia push w projekcie.

  2. Prześlij klucz uwierzytelniania APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APN, utwórz go w Centrum dla deweloperów Apple.

    1. W konsoli Firebase projektu kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie kartę Cloud Messaging.

    2. W sekcji Klucz uwierzytelniania APNs w sekcji Konfiguracja aplikacji na iOS kliknij przycisk Prześlij.

    3. Przejdź do lokalizacji, w której został zapisany klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny w  Centrum dla deweloperów Apple) i kliknij Prześlij.

    Jeśli masz już certyfikat APNs, możesz go przesłać.

  3. W Xcode włącz w projekcie obsługę trybów działania w tle, a potem zaznacz pola wyboru trybów Pobieranie w tle i Powiadomienia zdalne.

Konfigurowanie weryfikacji reCAPTCHA

Aby umożliwić pakietowi Firebase SDK korzystanie z weryfikacji reCAPTCHA:

  1. Dodawanie niestandardowych schematów URL do projektu Xcode:
    1. Otwórz konfigurację projektu: kliknij dwukrotnie nazwę projektu w widoku drzewa po lewej stronie. W sekcji CELE wybierz swoją aplikację, a potem kliknij kolejno karty Informacje i Typy adresów URL.
    2. Kliknij przycisk + i dodaj zakodowany identyfikator aplikacji jako schemat adresu URL. Zaszyfrowany identyfikator aplikacji znajdziesz na stronie Ustawienia ogólne w konsoli Firebase, w sekcji dotyczącej aplikacji na iOS. Pozostaw puste pozostałe pola.

      Po zakończeniu konfiguracja powinna wyglądać mniej więcej tak (ale z wartościami odpowiednimi dla Twojej aplikacji):

      Zrzut ekranu interfejsu konfiguracji niestandardowego schematu URL w Xcode
  2. Opcjonalnie: jeśli chcesz dostosować sposób wyświetlania przez aplikację elementu SFSafariViewController podczas wyświetlania reCAPTCHA użytkownikowi, utwórz niestandardową klasę zgodną z protokołem AuthUIDelegate i przekaż ją do elementu verifyPhoneNumber(_:uiDelegate:completion:).

Wysyłanie kodu weryfikacyjnego na telefon użytkownika

Aby rozpocząć logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs z prośbą o podanie numeru telefonu, a potem wywołaj funkcję verifyPhoneNumber(_:uiDelegate:completion:), aby poprosić Firebase o wysłanie kodu uwierzytelniania na telefon użytkownika SMS-em:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne różnią się w zależności od kraju, ale zgodnie ze sprawdzoną metodą i aby określić oczekiwania użytkowników, należy ich poinformować, że jeśli korzystają z logowania przez telefon, mogą otrzymać SMS-a z weryfikacją i że obowiązują standardowe stawki.

  2. Zadzwoń do verifyPhoneNumber(_:uiDelegate:completion:), przekazując numer telefonu użytkownika.
    SwiftObjective-C
    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
      // ...
  }
     
    [[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 verifyPhoneNumber jest reentrantna: jeśli wywołasz ją kilka razy, na przykład w metodzie onAppear widoku, metoda verifyPhoneNumber nie wyśle drugiego SMS-a, chyba że pierwotne żądanie przekroczy limit czasu.

    Gdy wywołasz funkcję verifyPhoneNumber(_:uiDelegate:completion:), Firebase wysyła do Twojej aplikacji powiadomienie push bez dźwięku lub uruchamia test reCAPTCHA. Gdy aplikacja otrzyma powiadomienie lub użytkownik ukończy zadanie reCAPTCHA, Firebase wyśle SMS-a z kodem uwierzytelniającym na podany numer telefonu i przekaże identyfikator weryfikacji do funkcji zakończenia. Aby zalogować użytkownika, musisz podać kod weryfikacyjny i identyfikator weryfikacyjny.

    Wiadomość SMS wysłana przez Firebase może być również zlokalizowana przez określenie języka uwierzytelniania za pomocą właściwości languageCode w usłudze uwierzytelniania.

    SwiftObjective-C
     // Change language code to french.
 Auth.auth().languageCode = "fr";
     
     // Change language code to french.
 [FIRAuth auth].languageCode = @"fr";

  3. Zapisz identyfikator weryfikacji i przywróć go po załadowaniu aplikacji. Dzięki temu masz pewność, że nadal masz prawidłowy identyfikator weryfikacji, jeśli aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (np. podczas przełączania się na aplikację SMS).

    Identyfikator weryfikacji możesz zapisać w dowolny sposób. Najprostszym sposobem jest zapisanie identyfikatora weryfikacji za pomocą obiektu NSUserDefaults:

    SwiftObjective-C
    UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
     
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
[defaults setObject:verificationID forKey:@"authVerificationID"];

    Następnie możesz przywrócić zapisaną wartość:

    SwiftObjective-C
    let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
     
    NSString *verificationID = [defaults stringForKey:@"authVerificationID"];

Jeśli wywołanie funkcji verifyPhoneNumber(_:uiDelegate:completion:) powiedzie się, 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 w aplikacji kod weryfikacyjny z SMS-a, zaloguj go, tworząc obiekt FIRPhoneAuthCredential z kodem weryfikacyjnym i identyfikatorem weryfikacji, a następnie przekazując ten obiekt do signInWithCredential:completion:.

  1. Uzyskaj kod weryfikacyjny od użytkownika.
  2. Utwórz obiekt FIRPhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacji.
    SwiftObjective-C
    let credential = PhoneAuthProvider.provider().credential(
  withVerificationID: verificationID,
  verificationCode: verificationCode
)
     
    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
    credentialWithVerificationID:verificationID
                verificationCode:userInput];
  3. Zaloguj użytkownika za pomocą obiektu FIRPhoneAuthCredential:
    SwiftObjective-C
    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
    // ...
}
     
    [[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 z fikcyjnymi numerami telefonów

Na potrzeby programowania możesz skonfigurować fikcyjne numery telefonów w konsoli Firebase. Testowanie z użyciem fikcyjnych numerów telefonów ma te zalety:

  • Testowanie uwierzytelniania numeru telefonu bez zużywania limitu użycia.
  • Testowanie uwierzytelniania numeru telefonu bez wysyłania SMS-a.
  • Przeprowadzanie kolejnych testów z użyciem tego samego numeru telefonu bez ograniczenia przepustowości. Pozwala to zminimalizować ryzyko odrzucenia aplikacji podczas procesu sprawdzania w App Store, jeśli recenzent użyje tego samego numeru telefonu do testowania.
  • Testowanie w środowiskach programistycznych bez konieczności wprowadzania dodatkowych zmian, np. możliwość tworzenia w symulatorze iOS lub emulatorze Androida bez Usług Google Play.
  • pisać testy integracyjne bez blokowania przez zabezpieczenia stosowane zwykle w rzeczywistych środowiskach produkcyjnych;

Fikcyjne numery telefonów muszą spełniać te wymagania:

  1. Upewnij się, że używasz numerów telefonów, które są fikcyjne i nie istnieją. Firebase Authentication nie pozwala na ustawienie istniejących numerów telefonów używanych przez prawdziwych użytkowników jako numerów testowych. Możesz na przykład użyć numerów z prefiksem 555 jako testowych numerów telefonów w Stanach Zjednoczonych, np.: +1 650-555-3434
  2. Numery telefonów muszą być sformatowane zgodnie z ograniczeniami dotyczącymi długości i innych ograniczeń. Nadal będą one podlegać takiej samej weryfikacji jak numer telefonu rzeczywistego użytkownika.
  3. Możesz dodać maksymalnie 10 numerów telefonów na potrzeby programowania.
  4. Używaj testowych numerów telefonów i kodów, które są trudne do odgadnięcia i często się zmieniają.

Tworzenie fikcyjnych numerów telefonów i kodów weryfikacyjnych

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie.
  2. Na karcie Metoda logowania włącz opcję Dostawca telefonu, jeśli nie została jeszcze włączona.
  3. Otwórz menu Numery telefonu do testowania.
  4. Podaj numer telefonu, który chcesz przetestować, np. +1 650-555-3434.
  5. Podaj 6-cyfrowy kod weryfikacyjny dla tego numeru, np. 654321.
  6. 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ąć używać fikcyjnego numeru telefonu w aplikacji. Dzięki temu możesz przeprowadzać ręczne testy na etapie programowania bez problemów z limitem lub ograniczeniem szybkości. Możesz też przetestować aplikację bezpośrednio na symulatorze iOS lub emulatorze Androida bez instalowania Usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, nie wyślemy SMS-a. Aby się zalogować, musisz podać skonfigurowany wcześniej kod weryfikacyjny.

Po zakończeniu logowania tworzymy użytkownika Firebase z tym numerem telefonu. Użytkownik ma takie same właściwości i takie samo zachowanie jak użytkownik z prawdziwym numerem telefonu. Może też uzyskiwać dostęp do usługi Realtime Database/Cloud Firestore i innych usług w taki sam sposób. Podczas tego procesu token identyfikacyjny ma to samo podpisywanie, co użytkownik z prawdziwym numerem telefonu.

Inną opcją jest ustawienie roli testowej za pomocą roszczeń niestandardowych dla tych użytkowników, aby odróżnić ich jako fałszywych użytkowników, jeśli chcesz jeszcze bardziej ograniczyć dostęp.

Testowanie integracji

Oprócz testów ręcznych Firebase Authentication udostępnia interfejsy API, które ułatwiają tworzenie testów integracyjnych na potrzeby testowania uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji przez wyłączenie wymagań reCAPTCHA w internecie i cichych powiadomień push na iOS. Dzięki temu testowanie automatyzacji jest możliwe w tych procesach i łatwiej je wdrożyć. Dodatkowo umożliwiają testowanie procesów weryfikacji błyskawicznej na urządzeniach z Androidem.

W iOS przed wywołaniem verifyPhoneNumber ustawienie appVerificationDisabledForTesting musi być ustawione na TRUE. Proces ten nie wymaga tokena APN ani wysyłania powiadomień push w tle, co ułatwia testowanie w symulacji. Spowoduje to też wyłączenie zastępczego procesu reCAPTCHA.

Pamiętaj, że gdy weryfikacja w aplikacji jest wyłączona, nie możesz zalogować się, używając numeru telefonu, który nie jest fikcyjny. Z tym interfejsem API można używać tylko fikcyjnych numerów telefonów.

SwiftObjective-C
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
    }];
}];
 
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;
    }];
}];

Załącznik: logowanie się na telefonie bez szyfrowania za pomocą klucza symetrycznego

Firebase Authentication używa metody swizzingu, aby automatycznie pobierać token APN Twojej aplikacji, obsługiwać powiadomienia push bez dźwięku wysyłane przez Firebase do aplikacji oraz automatycznie przechwytywać przekierowanie z niestandardowego schematu z strony weryfikacji reCaptcha.

Jeśli nie chcesz używać swizlowania, możesz je wyłączyć, dodając do pliku Info.plist aplikacji flagę FirebaseAppDelegateProxyEnabled i ustawiając ją na NO. Pamiętaj, że ustawienie tej opcji na NO wyłącza też zamianę dla innych usług Firebase, w tym dla Firebase Cloud Messaging.

Jeśli wyłączysz zamianę, musisz wyraźnie przekazać token urządzenia APN, powiadomienia push i adres URL przekierowania schematu niestandardowego do Firebase Authentication.

Jeśli tworzysz aplikację SwiftUI, musisz też wyraźnie przekazać token urządzenia APN, powiadomienia push i adres URL przekierowania schematu niestandardowego do Firebase Authentication.

Aby uzyskać token urządzenia APN, zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:), a w niej przekaż token urządzenia do metody setAPNSToken(_:type:) w komponencie Auth.

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

  // Further handling of the device token if needed by the app
  // ...
}
 
- (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 metodie application(_:didReceiveRemoteNotification:fetchCompletionHandler:): sprawdź, czy są powiadomienia związane z uwierzytelnianiem Firebase. W tym celu wywołaj metodę canHandleNotification(_:) klasy Auth.

SwiftObjective-C
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.
}
 
- (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 schematu niestandardowego, zaimplementuj metodę application(_:open:options:) i w niej prześlij adres URL do metody canHandleURL(_:) w klasie Auth.

SwiftObjective-C
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.
}
 
- (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, wdróż metodę scene(_:openURLContexts:) i w niej przekaż adres URL do metody canHandleURL(_:) klasy Auth.

SwiftObjective-C
func scene(_ scene: UIScene, openURLContexts URLContexts: Set&ltUIOpenURLContext&gt) {
  for urlContext in URLContexts {
      let url = urlContext.url
      _ = Auth.auth().canHandle(url)
  }
  // URL not auth related; it should be handled separately.
}
 
- (void)scene:(UIScene *)scene openURLContexts:(NSSet&ltUIOpenURLContext *&gt *)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 zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z danymi logowania, czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami dostawcy uwierzytelniania. To nowe konto jest przechowywane w projekcie Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach w projekcie, niezależnie od tego, jak użytkownik się loguje.

  • W swoich aplikacjach możesz pobrać podstawowe informacje o profilu użytkownika z obiektu User . Zobacz Zarządzanie użytkownikami.

  • W regułach Firebase Realtime Database i Cloud Storage Regułach bezpieczeństwa możesz pobrać z zmiennej auth unikalny identyfikator zalogowanego użytkownika i użyć go do kontrolowania dostępu użytkownika do danych.

Możesz zezwolić użytkownikom na logowanie się w aplikacji za pomocą danych logowania od wielu dostawców uwierzytelniania, połączając je z dotychczasowym kontem użytkownika.

Aby wylogować użytkownika, zadzwoń pod numer signOut:.

SwiftObjective-C
let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}
 
NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Możesz też dodać kod do obsługi błędów w całym zakresie błędów uwierzytelniania. Zobacz Obsługa błędów.