Uwierzytelnij się w Firebase na iOS przy użyciu numeru telefonu

Za pomocą Uwierzytelniania Firebase możesz zalogować się użytkownika, wysyłając wiadomość SMS na jego telefon. Użytkownik loguje się za pomocą kodu jednorazowego zawartego w wiadomości SMS.

Najprostszym sposobem, aby dodać numer telefonu logowania się do aplikacji jest użycie FirebaseUI , który obejmuje drop-in logowania widżet, który implementuje logowania przepływów dla numeru telefonu logowania, jak i opartych na hasłach i stowarzyszonego znak -w. W tym dokumencie opisano, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu Firebase SDK.

Zanim zaczniesz

  1. Dodaj Firebase do projektu iOS .
  2. Obejmują następujące strąków w swoim Podfile :
    pod 'Firebase/Auth'
    
  3. Jeśli nie zostały jeszcze podłączone swoją aplikację do projektu Firebase, zrobić 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ć 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 na podstawie numeru telefonu w swojej aplikacji, powinieneś oferować je wraz z bezpieczniejszymi metodami logowania i informować użytkowników o kompromisach związanych z bezpieczeństwem korzystania z logowania za pomocą numeru telefonu.

Włącz logowanie za pomocą numeru telefonu w projekcie Firebase

Aby logować użytkowników przez SMS, musisz najpierw włączyć metodę logowania za pomocą numeru telefonu dla swojego projektu Firebase:

  1. W konsoli Firebase otwórz sekcję uwierzytelniania.
  2. Na stronie logowania w metodzie, należy włączyć logowania metodą numer telefonu.

Limit żądań logowania za pomocą numeru telefonu Firebase jest na tyle wysoki, że nie ma 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 cenową stronę.

Włącz weryfikację aplikacji

Aby korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy żądania logowania za pomocą numeru telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase realizuje to na dwa sposoby:

  • Powiadomienia milczy APN: Po zalogowaniu się użytkownik z ich numeru telefonu po raz pierwszy na urządzeniu, uwierzytelnianie Firebase wysyła żeton do urządzenia za pomocą powiadomienia push cichego. Jeśli Twoja aplikacja pomyślnie odbierze powiadomienie z Firebase, możesz zalogować się za pomocą numeru 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 użytkownik odmawiający otrzymywania powiadomień APN w aplikacji. Dzięki temu aplikacja nie musi prosić użytkownika o pozwolenie na otrzymywanie powiadomień push podczas wdrażania uwierzytelniania numeru telefonu Firebase.

  • weryfikacja Odśwież: W przypadku wysyłania lub odbierania powiadomienia push cichy nie jest to możliwe, na przykład, gdy użytkownik ma wyłączoną odświeżanie w tle dla aplikacji, lub podczas testowania aplikacji na symulatorze iOS, uwierzytelnianie Firebase używa weryfikacji reCAPTCHA aby zakończyć telefon proces logowania. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania jakichkolwiek problemów przez użytkownika.

Gdy ciche powiadomienia push są prawidłowo skonfigurowane, tylko bardzo mały procent użytkowników odczuje przepływ reCAPTCHA. Niemniej jednak należy upewnić się, że logowanie za pomocą numeru telefonu działa poprawnie, niezależnie od tego, czy dostępne są ciche powiadomienia wypychane.

Zacznij otrzymywać ciche powiadomienia

Aby włączyć powiadomienia APN do użytku z Uwierzytelnianiem Firebase:

  1. W Xcode, włączyć powiadomienia push dla swojego projektu.
  2. Prześlij swój klucz uwierzytelniania APNs do Firebase. Jeżeli nie masz jeszcze klucza uwierzytelniania APN, upewnij się, aby utworzyć w Państwa firmy Apple Developer Center .

    1. Wewnątrz projektu w konsoli Firebase, wybierz ikonę koła zębatego, wybierz Ustawienia projektu, a następnie wybrać zakładkę Cloud Messaging.

    2. W APN klucza uwierzytelniającego pod iOS konfiguracji aplikacji, kliknij przycisk Prześlij.

    3. Przejdź do lokalizacji, w której został zapisany klucz, zaznacz go i kliknij przycisk Otwórz. Dodaj identyfikator klucza do klucza (dostępne w firmy Apple Developer Center użytkownika ) i kliknij przycisk Prześlij.

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

Skonfiguruj weryfikację reCAPTCHA

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

  1. Dodaj niestandardowe schematy adresów URL do swojego projektu Xcode:
    1. Otwórz konfigurację projektu: kliknij dwukrotnie nazwę projektu w lewym widoku drzewa. Wybierz swoją aplikację z sekcji cele, a następnie wybierz kartę Informacje i rozwinąć sekcję Typy URL.
    2. Kliknij przycisk + i dodać schemat URL dla odwróconej ID klienta. Aby znaleźć tę wartość, otwórz GoogleService-Info.plist plik konfiguracyjny, a spojrzenie na REVERSED_CLIENT_ID klucza. Skopiuj wartość tego klucza, i wklej go w adresie URL Schematy Box na stronie konfiguracji. Pozostałe pola pozostaw puste.

      Po zakończeniu twoja konfiguracja powinna wyglądać podobnie do poniższej (ale z wartościami specyficznymi dla aplikacji):

  2. Opcjonalnie: Jeśli chcesz, aby dostosować sposób Twoja aplikacja prezentuje SFSafariViewController lub UIWebView podczas wyświetlania reCAPTCHA do użytkownika, tworzenia niestandardowej klasy, który jest zgodny z FIRAuthUIDelegate protokół i przekazać go do verifyPhoneNumber:UIDelegate:completion: .

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować numer telefonu logowania, przedstawić użytkownikowi interfejs, który wyświetli monit o podanie swojego numeru telefonu, a następnie zadzwonić verifyPhoneNumber:UIDelegate:completion: do wniosku że Firebase wysłać kod uwierzytelniania użytkownika telefonu przez SMS:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale najlepszym rozwiązaniem i określeniem oczekiwań wobec użytkowników jest poinformowanie ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązują standardowe stawki.

  2. Zadzwoń verifyPhoneNumber:UIDelegate:completion: , przechodząc do niego 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
      // ...
    }];

    Podczas rozmowy telefonicznej verifyPhoneNumber:UIDelegate:completion: , Firebase wysyła powiadomienia push cichego do aplikacji, lub kwestie wyzwanie reCAPTCHA dla użytkownika. Gdy 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 uzupełniania. Do zalogowania użytkownika będą potrzebne zarówno kod weryfikacyjny, jak i identyfikator weryfikacyjny.

    Wiadomość SMS wysłana przez Firebase mogą być także lokalizowane poprzez określenie języka auth poprzez languageCode nieruchomości na instancji Auth.

    Szybki

     // Change language code to french.
     Auth.auth().languageCode = "fr";
    

    Cel C

     // Change language code to french.
     [FIRAuth auth].languageCode = @"fr";
    
  3. Zapisz identyfikator weryfikacyjny i przywróć go po załadowaniu aplikacji. W ten sposób możesz upewnić się, że nadal masz prawidłowy identyfikator weryfikacyjny, jeśli Twoja aplikacja zostanie zamknięta przed ukończeniem przez użytkownika procesu logowania (na przykład podczas przełączania do aplikacji SMS).

    Możesz zachować identyfikator weryfikacyjny w dowolny sposób. Prostym sposobem jest zapisanie identyfikatora weryfikacji z NSUserDefaults obiektu:

    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 verifyPhoneNumber:UIDelegate:completion: uda, można poprosi użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzymują go w wiadomości SMS.

Zaloguj się użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik udostępnia swoją aplikację z kodem weryfikacyjnym z wiadomości SMS, zaloguj użytkownika w poprzez stworzenie FIRPhoneAuthCredential obiekt z kodem weryfikacyjnym i ID weryfikacji i przejściu tego obiektu do signInWithCredential:completion: .

  1. Uzyskaj kod weryfikacyjny od użytkownika.
  2. Tworzenie FIRPhoneAuthCredential obiekt z kodem weryfikacyjnym i ID weryfikacji.

    Szybki

    let credential = PhoneAuthProvider.provider().credential(
      withVerificationID: verificationID,
      verificationCode: verificationCode
    )

    Cel C

    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
        credentialWithVerificationID:verificationID
                    verificationCode:userInput];
  3. Zaloguj się użytkownika z FIRPhoneAuthCredential obiektu:

    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;
      // ...
    }];

Testuj z fikcyjnymi numerami telefonów

Za pomocą konsoli Firebase możesz skonfigurować fikcyjne numery telefonów do programowania. Testowanie z fikcyjnymi numerami telefonów zapewnia następujące korzyści:

  • Przetestuj uwierzytelnianie numeru telefonu bez zużywania limitu użycia.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania wiadomości SMS.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu bez dławienia. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Łatwe testowanie w środowiskach programistycznych bez dodatkowego wysiłku, na przykład możliwość programowania w symulatorze systemu iOS lub emulatorze systemu Android bez usług Google Play.
  • Twórz testy integracyjne bez blokowania przez kontrole bezpieczeństwa stosowane zwykle w przypadku prawdziwych numerów telefonów w środowisku produkcyjnym.

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

  1. Upewnij się, że używasz numerów telefonów, które są rzeczywiście 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 555 prefiksem numery jak numery telefonów Test USA, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być poprawnie sformatowane pod kątem długości i innych ograniczeń. Będą nadal przechodzić tę samą weryfikację, co numer telefonu prawdziwego użytkownika.
  3. Możesz dodać maksymalnie 10 numerów telefonów do rozwoju.
  4. Używaj testowych numerów/kodów telefonów, które są trudne do odgadnięcia i często je zmieniaj.

Twórz fikcyjne numery telefonów i kody weryfikacyjne

  1. W konsoli Firebase otwórz sekcję uwierzytelniania.
  2. W Znaku w zakładce metodzie umożliwienia usługodawcy telefonu, jeśli nie masz.
  3. Otwórz numery telefonów do testowania menu akordeon.
  4. Podać numer telefonu, który ma na celu sprawdzenie, na przykład: +1 650-555-3434.
  5. Zapewnienie 6-cyfrowy kod dla tej określonej ilości, na przykład: 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 bezpośrednio zacząć używać fikcyjnego numeru telefonu w swojej aplikacji. Pozwala to na ręczne testowanie na etapach rozwoju bez problemów z przydziałem 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, rzeczywisty SMS nie zostanie wysłany. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby zakończyć logowanie.

Po zakończeniu logowania zostanie utworzony użytkownik Firebase z tym numerem telefonu. Użytkownik zachowuje się i ma takie same właściwości jak użytkownik z prawdziwym numerem telefonu i może w ten sam sposób uzyskiwać dostęp do Bazy danych czasu rzeczywistego/Cloud Firestore i innych usług. Token ID wybity podczas tego procesu ma taki sam podpis jak użytkownik z prawdziwym numerem telefonu.

Innym rozwiązaniem jest ustawienie roli testowego poprzez niestandardowe roszczenia dotyczące tych użytkowników, aby odróżnić je jako użytkowników fałszywych jeśli chcesz dodatkowo ograniczyć dostęp.

Testy integracyjne

Oprócz testów ręcznych Uwierzytelnianie Firebase udostępnia interfejsy API ułatwiające pisanie testów integracji na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w Internecie i ciche powiadomienia push w systemie iOS. Dzięki temu testowanie automatyzacji w tych przepływach jest możliwe i łatwiejsze do wdrożenia. Ponadto zapewniają możliwość testowania przepływów natychmiastowej weryfikacji w systemie Android.

Na systemie iOS appVerificationDisabledForTesting ustawienie musi być ustawiony na TRUE przed wywołaniem verifyPhoneNumber . Jest to przetwarzane bez konieczności stosowania tokena APNs lub wysyłania cichych powiadomień push w tle, co ułatwia testowanie w symulatorze. Powoduje to również wyłączenie przepływu awaryjnego reCAPTCHA.

Pamiętaj, że po wyłączeniu weryfikacji aplikacji użycie niefikcyjnego numeru telefonu nie zakończy logowania. Ten interfejs API może 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 swizzling

Uwierzytelnianie Firebase wykorzystuje swizzling metody, aby automatycznie uzyskać token APNs Twojej aplikacji, obsługiwać ciche powiadomienia push wysyłane przez Firebase do Twojej aplikacji oraz automatycznie przechwytywać niestandardowe przekierowanie schematu ze strony weryfikacji reCAPTCHA podczas weryfikacji.

Jeśli nie wolą używać swizzling, można ją wyłączyć przez dodanie flagi FirebaseAppDelegateProxyEnabled do pliku Info.plist Twojej aplikacji i ustawienie go na NO . Należy pamiętać, że ustawienie tej flagi do NO również wyłącza swizzling dla innych produktów, w tym Firebase 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.

Aby uzyskać znacznik urządzenia APN realizować application:didRegisterForRemoteNotificationsWithDeviceToken: sposób, w tym, przechodzi z urządzenia żeton do FIRAuth jest setAPNSToken:type: metody.

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.
}

Do powiadomień pałąkiem do przesuwania w application:didReceiveRemoteNotification:fetchCompletionHandler: metody, należy sprawdzić Firebase auth powiązanych powiadomień poprzez wywołanie FIRAuth „s canHandleNotification: metody.

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, developer should handle it.
}

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, developer should handle it.
}

Aby obsłużyć przekierowania Schemat niestandardowy, wdrożyć application:openURL:sourceApplication:annotation: metodę dla urządzeń z systemem iOS 8 i starszych, a także application:openURL:options: Metoda dla urządzeń z systemem iOS 9 i nowsze, a w nich przekazać URL do FIRAuth „s canHandleURL metody.

Szybki

// For iOS 9+
func application(_ application: UIApplication, open url: URL,
    options: [UIApplicationOpenURLOptionsKey : Any]) -> Bool {
  if Auth.auth().canHandle(url) {
    return true
  }
  // URL not auth related, developer should handle it.
}

// For iOS 8-
func application(_ application: UIApplication,
                 open url: URL,
                 sourceApplication: String?,
                 annotation: Any) -> Bool {
  if Auth.auth().canHandle(url) {
    Return true
  }
  // URL not auth related, developer should handle it.
}

Cel C

// For iOS 9+
- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary<UIApplicationOpenURLOptionsKey, id> *)options {
  if ([[FIRAuth auth] canHandleURL:url]) {
    return YES;
  }
  // URL not auth related, developer should handle it.
}

// For iOS 8-
- (BOOL)application:(UIApplication *)application
            openURL:(NSURL *)url
  sourceApplication:(NSString *)sourceApplication
         annotation:(id)annotation {
  if ([[FIRAuth auth] canHandleURL:url]) {
    return YES;
  }
  // URL not auth related, developer should handle it.
}

Jeśli używasz SwiftUI lub UISceneDelegate , aby obsłużyć przekierowanie, wdrożenie scene:openURLContexts: metodę, aw nich przekazać URL do FIRAuth „s canHandleURL metody.

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, developer should handle it.
}

Cel C

- (void)scene:(UIScene *)scene openURLContexts:(NSSet<UIOpenURLContext *> *)URLContexts {
  for (UIOpenURLContext *urlContext in URLContexts) {
    [FIRAuth.auth canHandleURL:urlContext.url];
    // URL not auth related, developer should handle it.
  }
}

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — przy użyciu których użytkownik się zalogował. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się on loguje.

  • W aplikacjach, można uzyskać podstawowe informacje o profilu użytkownika z FIRUser obiektu. Patrz Zarządzanie użytkownikami .

  • W bazie danych Firebase Realtime i Cloud Storage zasad bezpieczeństwa , można uzyskać podpisanego w unikalnym identyfikatorem użytkownika użytkownika z auth zmiennej i użyć go do kontroli, jakie dane dostępu może użytkownik.

Można zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania przez łączenie auth poświadczenia dostawcy do istniejącego konta użytkownika.

Aby wylogować użytkownika, zadzwoń 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 rączką .