Save the date - Google I/O returns May 18-20. Register to get the most out of the digital experience: Build your schedule, reserve space, participate in Q&As, earn Google Developer profile badges, and more. Register now
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

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

Możesz użyć uwierzytelniania Firebase, aby zalogować użytkownika, wysyłając wiadomość SMS na telefon użytkownika. Użytkownik loguje się za pomocą jednorazowego kodu zawartego w wiadomości SMS.

Najłatwiejszym sposobem dodania logowania za pomocą numeru telefonu do aplikacji jest użycie interfejsu FirebaseUI , który zawiera widżet logowania, który implementuje przepływy logowania do logowania za pomocą numeru telefonu, a także logowanie oparte na haśle i federacyjne -w. W tym dokumencie opisano, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.

Zanim zaczniesz

  1. Dodaj Firebase do swojego projektu na iOS .
  2. Uwzględnij następujące pody w swoim Podfile :
    pod 'Firebase/Auth'
    
  3. Jeśli nie połączyłeś jeszcze swojej aplikacji z projektem Firebase, zrób to z konsoli Firebase .

Obawy dotyczące bezpieczeństwa

Uwierzytelnianie za pomocą 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 w zakresie bezpieczeństwa związanych z używaniem logowania za pomocą numeru telefonu.

Włącz logowanie przy użyciu numeru telefonu do projektu Firebase

Aby logować użytkowników za pomocą wiadomości SMS, musisz najpierw włączyć metodę logowania przy użyciu numeru telefonu w projekcie Firebase:

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

Limit żądań logowania na numer telefonu w 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 stronę z cenami .

Włącz weryfikację aplikacji

Aby korzystać z uwierzytelniania numeru telefonu, Firebase musi mieć możliwość zweryfikowania, czy żądania logowania na numer telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase można to osiągnąć na dwa sposoby:

  • Ciche powiadomienia APN : gdy po raz pierwszy logujesz się na urządzeniu za pomocą jego numeru telefonu, uwierzytelnianie Firebase wysyła token do urządzenia za pomocą cichego powiadomienia wypychanego. Jeśli Twoja aplikacja pomyślnie otrzyma powiadomienie z Firebase, można kontynuować logowanie za pomocą numeru telefonu.

    W przypadku iOS 8.0 i nowszych ciche powiadomienia nie wymagają wyraźnej zgody użytkownika i dlatego użytkownik odmówi otrzymywania powiadomień APN w aplikacji nie ma na nie wpływu. Dzięki temu aplikacja nie musi prosić użytkownika o pozwolenie na otrzymywanie powiadomień push podczas implementacji uwierzytelniania numeru telefonu Firebase.

  • Weryfikacja reCAPTCHA : w przypadku, gdy wysyłanie lub odbieranie 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 ukończenia telefonu proces logowania. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania przez użytkownika czegokolwiek.

Gdy 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 na numer telefonu działa poprawnie, 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:

  1. W Xcode włącz powiadomienia push dla swojego projektu.
  2. Prześlij swój klucz uwierzytelniania APN do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APNs, zobacz Konfigurowanie APN za pomocą FCM .

    1. W projekcie w konsoli Firebase wybierz ikonę koła zębatego, wybierz opcję Ustawienia projektu , a następnie wybierz kartę Komunikacja w chmurze .

    2. W kluczu uwierzytelniania APN w konfiguracji aplikacji na iOS kliknij przycisk Prześlij .

    3. Przejdź do lokalizacji, w której zapisałeś klucz, wybierz go i kliknij Otwórz . Dodaj identyfikator klucza dla klucza (dostępny w sekcji Certyfikaty, identyfikatory i profile w Apple Developer Member Center ) i kliknij Prześlij .

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

Skonfiguruj weryfikację reCAPTCHA

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

  1. Dodaj niestandardowe schematy adresów URL do 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 rozwiń sekcję Typy adresów URL .
    2. Kliknij przycisk + i dodaj schemat adresu URL dla swojego odwróconego identyfikatora klienta. Aby znaleźć tę wartość, otwórz plik konfiguracyjny GoogleService-Info.plist i poszukaj klucza REVERSED_CLIENT_ID . Skopiuj wartość tego klucza i wklej go w polu Schematy adresów URL na stronie konfiguracji. Pozostałe pola pozostaw puste.

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

  2. Opcjonalnie : jeśli chcesz dostosować sposób, w jaki aplikacja prezentuje SFSafariViewController lub UIWebView podczas wyświetlania reCAPTCHA użytkownikowi, utwórz niestandardową klasę zgodną z protokołem FIRAuthUIDelegate i przekaż ją do verifyPhoneNumber:UIDelegate:completion:

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować logowanie za pomocą numeru telefonu, należy przedstawić użytkownikowi interfejs, który zachęca do podania numeru telefonu, a następnie zadzwonić do verifyPhoneNumber:UIDelegate:completion: z prośbą o wysłanie przez verifyPhoneNumber:UIDelegate:completion: kodu uwierzytelniającego na telefon użytkownika przez SMS:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale zgodnie z najlepszą praktyką i aby określić oczekiwania użytkowników, należy ich poinformować, że jeśli korzystają z logowania telefonicznego, mogą otrzymać wiadomość SMS do weryfikacji i zastosować standardowe stawki.

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

    Gdy dzwonisz do verifyPhoneNumber:UIDelegate:completion: wysyła ciche powiadomienie push do Twojej aplikacji lub wysyła użytkownikowi wezwanie reCAPTCHA. Gdy Twoja aplikacja otrzyma powiadomienie lub użytkownik ukończy wyzwanie reCAPTCHA, Firebase wyśle ​​wiadomość SMS zawierającą kod uwierzytelniający na podany numer telefonu i przekaże identyfikator weryfikacyjny do funkcji ukoń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 we właściwości languageCode w wystąpieniu 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 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 SMS).

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

Zaloguj użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik FIRPhoneAuthCredential aplikacji kod weryfikacyjny z wiadomości SMS, zaloguj się, tworząc obiekt FIRPhoneAuthCredential z kodu weryfikacyjnego i identyfikatora weryfikacyjnego i przekazując ten obiekt do signInWithCredential:completion:

  1. Uzyskaj kod weryfikacyjny od użytkownika.
  2. Utwórz obiekt FIRPhoneAuthCredential z 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];
  3. Zarejestruj 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;
      // ...
    }];

Testuj z fikcyjnymi numerami telefonów

W 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żytkowania.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania faktycznej wiadomości SMS.
  • Uruchom kolejne testy z tym samym numerem telefonu bez dławienia. Minimalizuje to ryzyko odrzucenia podczas procesu przeglądu App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Testuj z łatwością w środowiskach programistycznych bez dodatkowego wysiłku, takiego jak możliwość tworzenia w symulatorze iOS lub emulatorze Androida bez usług Google Play.
  • Pisz testy integracyjne bez blokowania przez kontrole bezpieczeństwa zwykle stosowane na rzeczywistych numerach telefonów w środowisku produkcyjnym.

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

  1. Upewnij się, że używasz numerów telefonów, które są rzeczywiście fikcyjne i jeszcze nie istnieją. Uwierzytelnianie Firebase nie pozwala ustawić istniejących numerów telefonów używanych przez rzeczywistych użytkowników jako numerów testowych. Jedną z opcji jest użycie 555 numerów z prefiksem jako numerów telefonów testowych w USA, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być poprawnie sformatowane pod względem długości i innych ograniczeń. Będą nadal przechodzić tę samą weryfikację, co numer telefonu rzeczywistego użytkownika.
  3. Możesz dodać do 10 numerów telefonów do programowania.
  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ę Uwierzytelnianie .
  2. Na karcie Metoda logowania włącz dostawcę telefonu, jeśli jeszcze tego nie zrobiłeś.
  3. Otwórz menu Numery telefonów do testowania akordeonu.
  4. Podaj numer telefonu, który chcesz przetestować, na przykład: +1 650-555-3434 .
  5. Podaj 6-cyfrowy kod weryfikacyjny dla tego konkretnego numeru, 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 wykonywanie ręcznych testów na etapach programowania bez problemów z przydziałami lub ograniczania 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, SMS nie zostanie wysłany. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby ukończyć logowanie.

Po zakończeniu logowania zostaje utworzony użytkownik Firebase z tym numerem telefonu. Użytkownik ma takie samo zachowanie i właściwości, jak prawdziwy użytkownik numeru telefonu i może uzyskać dostęp do bazy danych czasu rzeczywistego / Cloud Firestore i innych usług w ten sam sposób. Identyfikator wybity podczas tego procesu ma taki sam podpis jak prawdziwy użytkownik numeru telefonu.

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

Testy integracyjne

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

W systemie iOS ustawienie appVerificationDisabledForTesting musi mieć wartość TRUE przed wywołaniem funkcji verifyPhoneNumber . Jest to przetwarzane bez konieczności stosowania tokena APN lub wysyłania cichych powiadomień push w tle, co ułatwia testowanie w symulatorze. To również wyłącza przepływ zwrotny reCAPTCHA.

Pamiętaj, że gdy weryfikacja aplikacji jest wyłączona, logowanie się przy użyciu niefikcyjnego numeru telefonu nie powiedzie się. W tym interfejsie API można używać tylko fikcyjnych numerów telefonów.

Szybki

let phoneNumber = "+16505554567"

// This test verification code is specified for the given test phone number in the developer console.
let testVerificationCode = "123456"

Auth.auth().settings.isAppVerificationDisabledForTesting = TRUE
PhoneAuthProvider.provider().verifyPhoneNumber(phoneNumber, uiDelegate:nil) {
                                                            verificationID, error in
    if (error) {
      // Handles error
      self.handleError(error)
      return
    }
    let credential = PhoneAuthProvider.provider().credential(withVerificationID: verificationID ?? "",
                                                               verificationCode: testVerificationCode)
    Auth.auth().signInAndRetrieveData(with: credential) { authData, error in
      if (error) {
        // Handles error
        self.handleError(error)
        return
      }
      _user = authData.user
    }];
}];

Cel C

NSString *phoneNumber = @"+16505554567";

// This test verification code is specified for the given test phone number in the developer console.
NSString *testVerificationCode = @"123456";

[FIRAuth auth].settings.appVerificationDisabledForTesting = YES;
[[FIRPhoneAuthProvider provider] verifyPhoneNumber:phoneNumber
                                        completion:^(NSString *_Nullable verificationID,
                                                     NSError *_Nullable error) {
    if (error) {
      // Handles error
      [self handleError:error];
      return;
    }
    FIRAuthCredential *credential =
        [FIRPhoneAuthProvider credentialWithVerificationID:verificationID
                                          verificationCode:testVerificationCode];
    [FIRAuth auth] signInWithAndRetrieveDataWithCredential:credential
                                                completion:^(FIRUser *_Nullable user,
                                                             NSError *_Nullable error) {
      if (error) {
        // Handles error
        [self handleError:error];
        return;
      }
      _user = user;
    }];
}];

Dodatek: Logowanie telefoniczne bez przesuwania

Uwierzytelnianie Firebase korzysta z zamiany metod, aby automatycznie uzyskiwać token APN aplikacji, obsługiwać ciche powiadomienia push wysyłane przez Firebase do Twojej aplikacji oraz automatycznie przechwytywać przekierowanie schematu niestandardowego ze strony weryfikacji reCAPTCHA podczas weryfikacji.

Jeśli wolisz nie używać swizzlingu, możesz go wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled do pliku Info.plist swojej aplikacji i ustawiając ją na NO . Pamiętaj, że ustawienie tej flagi na NO wyłącza również swizzling dla innych produktów Firebase, w tym Firebase Cloud Messaging.

Jeśli wyłączysz swizzling, musisz jawnie przekazać token urządzenia APNs, powiadomienia push i 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.
}

Aby obsłużyć powiadomienia push, w application:didReceiveRemoteNotification:fetchCompletionHandler: metoda, sprawdź powiadomienia związane z uwierzytelnianiem FIRAuth wywołując FIRAuth canHandleNotification: .

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ć adres URL przekierowania schematu niestandardowego, zaimplementuj application:openURL:sourceApplication:annotation: metoda dla urządzeń z systemem iOS 8 i starszymi oraz application:openURL:options: metoda dla urządzeń z systemem iOS 9 i nowszych, a 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 loguje się po raz pierwszy, tworzone jest nowe konto użytkownika i jest ono łączone z poświadczeniami - to jest z nazwą użytkownika i hasłem, numerem telefonu lub informacjami dostawcy uwierzytelniania - zalogowanym użytkownikiem. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikacji użytkownika we wszystkich aplikacjach w Twoim projekcie, niezależnie od tego, w jaki sposób się on zaloguje.

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

  • W Firebase Realtime Database i Cloud Storage Rules możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik ma 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 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 również dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Zobacz Obsługa błędów .