Uwierzytelnij się w Firebase na platformach Apple, używając 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 FirebaseUI , który zawiera widżet logowania, który implementuje przepływy logowania na potrzeby logowania się za pomocą numeru telefonu, a także logowanie oparte na hasłach i federacyjne -W. W tym dokumencie opisano, jak zaimplementować proces logowania się za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.

Zanim zaczniesz

Użyj Menedżera pakietów Swift, aby zainstalować zależności Firebase i zarządzać nimi.

  1. W Xcode, przy otwartym projekcie aplikacji, przejdź do File > Add Packages .
  2. Po wyświetleniu monitu dodaj repozytorium SDK platform Firebase Apple:
  3.   https://github.com/firebase/firebase-ios-sdk.git
  4. Wybierz bibliotekę uwierzytelniania Firebase.
  5. Dodaj flagę -ObjC do sekcji Inne flagi linkera w ustawieniach kompilacji celu.
  6. Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.
Sprawdź także krok konfiguracji:
  1. Jeśli jeszcze nie połączyłeś aplikacji z projektem Firebase, zrób to z konsoli Firebase .

Obawy dotyczące bezpieczeństwa

Uwierzytelnianie przy użyciu samego numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ posiadanie numeru telefonu można łatwo przenosić pomiędzy użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik mogący odbierać wiadomości SMS może zalogować się na konto przy użyciu numeru telefonu urządzenia.

Jeśli w swojej aplikacji używasz logowania przy użyciu numeru telefonu, powinieneś zaoferować tę opcję obok bezpieczniejszych metod logowania i poinformować użytkowników o kompromisach w zakresie bezpieczeństwa, jakie wiążą się z logowaniem się za pomocą numeru telefonu.

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

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

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

Limit żądań logowania na numer telefonu w Firebase jest na tyle wysoki, że nie będzie to miało wpływu na większość aplikacji. Jeśli jednak chcesz zalogować bardzo dużą liczbę użytkowników przy użyciu uwierzytelniania telefonicznego, może być konieczne uaktualnienie planu cenowego. Zobacz stronę z cenami .

Włącz weryfikację aplikacji

Aby móc korzystać z uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy prośby o zalogowanie się na numer telefonu pochodzą z Twojej aplikacji. Uwierzytelnianie Firebase realizuje to na dwa sposoby:

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

    W przypadku systemu iOS 8.0 i nowszych ciche powiadomienia nie wymagają wyraźnej zgody użytkownika i dlatego nie ma na nie wpływu odmowa przez użytkownika otrzymywania powiadomień APN w aplikacji. Dlatego aplikacja nie musi pytać użytkownika o pozwolenie na otrzymywanie powiadomień push podczas wdrażania uwierzytelniania numeru telefonu Firebase.

  • Weryfikacja reCAPTCHA : w przypadku, gdy wysłanie lub odebranie cichego powiadomienia push nie jest możliwe, na przykład gdy użytkownik wyłączył odświeżanie w tle dla Twojej aplikacji lub podczas testowania aplikacji na symulatorze iOS, uwierzytelnianie Firebase wykorzystuje weryfikację reCAPTCHA do zakończenia połączenia telefonicznego przepływ logowania. Wyzwanie reCAPTCHA często można ukończyć bez konieczności rozwiązywania przez użytkownika czegokolwiek.

Jeśli ciche powiadomienia push są prawidłowo skonfigurowane, tylko niewielki procent użytkowników doświadczy przepływu reCAPTCHA. Niemniej jednak należy upewnić się, że logowanie za pomocą numeru telefonu działa prawidłowo, niezależnie od tego, czy dostępne są ciche powiadomienia push.

Zacznij otrzymywać ciche powiadomienia

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

  1. W Xcode włącz powiadomienia push dla swojego projektu.
  2. Prześlij swój klucz uwierzytelniający APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniającego APNs, pamiętaj o utworzeniu go w Apple Developer Member Center .

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

    2. W kluczu uwierzytelniania APN w obszarze 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 (dostępny w Apple Developer Member Center ) i kliknij Prześlij .

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

Skonfiguruj weryfikację reCAPTCHA

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

  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ę w sekcji CELE , następnie wybierz kartę Informacje i rozwiń sekcję Typy adresów URL .
    2. Kliknij przycisk + i dodaj zakodowany identyfikator aplikacji jako schemat adresu URL. Zakodowany identyfikator aplikacji znajdziesz na stronie Ustawienia ogólne konsoli Firebase, w sekcji aplikacji na iOS. Pozostałe pola pozostaw puste.

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

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

Wyślij kod weryfikacyjny na telefon użytkownika

Aby zainicjować logowanie za pomocą numeru telefonu, wyświetl użytkownikowi interfejs, który poprosi go o podanie numeru telefonu, a następnie wywołaj verifyPhoneNumber(_:uiDelegate:completion:) , aby poprosić Firebase o przesłanie kodu uwierzytelniającego na telefon użytkownika za pomocą wiadomości SMS:

  1. Uzyskaj numer telefonu użytkownika.

    Wymagania prawne są różne, ale w ramach najlepszej praktyki i w celu ustalenia oczekiwań użytkowników należy poinformować ich, że w przypadku korzystania z logowania przez telefon mogą otrzymać wiadomość SMS w celu weryfikacji i obowiązywać będą standardowe stawki.

  2. Wywołaj funkcję verifyPhoneNumber(_:uiDelegate:completion:) , przekazując jej numer telefonu użytkownika.

    Szybki

    PhoneAuthProvider.provider()
      .verifyPhoneNumber(phoneNumber, uiDelegate: nil) { verificationID, error in
          if let error = error {
            self.showMessagePrompt(error.localizedDescription)
            return
          }
          // Sign in using the verificationID and the code sent to the user
          // ...
      }

    Cel C

    [[FIRPhoneAuthProvider provider] verifyPhoneNumber:userInput
                                            UIDelegate:nil
                                            completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
      if (error) {
        [self showMessagePrompt:error.localizedDescription];
        return;
      }
      // Sign in using the verificationID and the code sent to the user
      // ...
    }];

    Metoda verifyPhoneNumber jest metodą współbieżną: jeśli wywołasz ją wiele razy, na przykład w metodzie onAppear widoku, metoda verifyPhoneNumber nie wyśle ​​drugiej wiadomości SMS, chyba że upłynął limit czasu pierwotnego żądania.

    Kiedy wywołujesz verifyPhoneNumber(_:uiDelegate:completion:) , Firebase wysyła ciche powiadomienie push do Twojej aplikacji lub wysyła do użytkownika wezwanie reCAPTCHA. Gdy Twoja aplikacja otrzyma powiadomienie lub użytkownik zakończy wyzwanie reCAPTCHA, Firebase wysyła wiadomość SMS zawierającą kod uwierzytelniający na podany numer telefonu i przekazuje identyfikator weryfikacyjny do funkcji zakończenia. Aby zalogować użytkownika, będziesz potrzebować zarówno kodu weryfikacyjnego, jak i identyfikatora weryfikacyjnego.

    Wiadomość SMS wysłaną przez Firebase można również zlokalizować, określając język uwierzytelniania za pomocą właściwości languageCode w 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 mieć pewność, że nadal masz ważny identyfikator weryfikacyjny, jeśli aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (na przykład podczas przełączania się do aplikacji do obsługi SMS-ów).

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

    Szybki

    UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
    

    Cel C

    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    [defaults setObject:verificationID forKey:@"authVerificationID"];
    

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

    Szybki

    let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
    

    Cel C

    NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
    

Jeśli wywołanie funkcji verifyPhoneNumber(_:uiDelegate:completion:) powiedzie się, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego po otrzymaniu go w wiadomości SMS.

Zaloguj użytkownika za pomocą kodu weryfikacyjnego

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

  1. Uzyskaj kod weryfikacyjny od użytkownika.
  2. Utwórz obiekt FIRPhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacyjnego.

    Szybki

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

    Cel C

    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
        credentialWithVerificationID:verificationID
                    verificationCode:userInput];
  3. Zaloguj użytkownika za pomocą obiektu FIRPhoneAuthCredential :

    Szybki

    Auth.auth().signIn(with: credential) { authResult, error in
        if let error = error {
          let authError = error as NSError
          if isMFAEnabled, authError.code == AuthErrorCode.secondFactorRequired.rawValue {
            // The user is a multi-factor user. Second factor challenge is required.
            let resolver = authError
              .userInfo[AuthErrorUserInfoMultiFactorResolverKey] as! MultiFactorResolver
            var displayNameString = ""
            for tmpFactorInfo in resolver.hints {
              displayNameString += tmpFactorInfo.displayName ?? ""
              displayNameString += " "
            }
            self.showTextInputPrompt(
              withMessage: "Select factor to sign in\n\(displayNameString)",
              completionBlock: { userPressedOK, displayName in
                var selectedHint: PhoneMultiFactorInfo?
                for tmpFactorInfo in resolver.hints {
                  if displayName == tmpFactorInfo.displayName {
                    selectedHint = tmpFactorInfo as? PhoneMultiFactorInfo
                  }
                }
                PhoneAuthProvider.provider()
                  .verifyPhoneNumber(with: selectedHint!, uiDelegate: nil,
                                     multiFactorSession: resolver
                                       .session) { verificationID, error in
                    if error != nil {
                      print(
                        "Multi factor start sign in failed. Error: \(error.debugDescription)"
                      )
                    } else {
                      self.showTextInputPrompt(
                        withMessage: "Verification code for \(selectedHint?.displayName ?? "")",
                        completionBlock: { userPressedOK, verificationCode in
                          let credential: PhoneAuthCredential? = PhoneAuthProvider.provider()
                            .credential(withVerificationID: verificationID!,
                                        verificationCode: verificationCode!)
                          let assertion: MultiFactorAssertion? = PhoneMultiFactorGenerator
                            .assertion(with: credential!)
                          resolver.resolveSignIn(with: assertion!) { authResult, error in
                            if error != nil {
                              print(
                                "Multi factor finanlize sign in failed. Error: \(error.debugDescription)"
                              )
                            } else {
                              self.navigationController?.popViewController(animated: true)
                            }
                          }
                        }
                      )
                    }
                  }
              }
            )
          } else {
            self.showMessagePrompt(error.localizedDescription)
            return
          }
          // ...
          return
        }
        // User is signed in
        // ...
    }

    Cel C

    [[FIRAuth auth] signInWithCredential:credential
                              completion:^(FIRAuthDataResult * _Nullable authResult,
                                           NSError * _Nullable error) {
        if (isMFAEnabled && error && error.code == FIRAuthErrorCodeSecondFactorRequired) {
          FIRMultiFactorResolver *resolver = error.userInfo[FIRAuthErrorUserInfoMultiFactorResolverKey];
          NSMutableString *displayNameString = [NSMutableString string];
          for (FIRMultiFactorInfo *tmpFactorInfo in resolver.hints) {
            [displayNameString appendString:tmpFactorInfo.displayName];
            [displayNameString appendString:@" "];
          }
          [self showTextInputPromptWithMessage:[NSString stringWithFormat:@"Select factor to sign in\n%@", displayNameString]
                               completionBlock:^(BOOL userPressedOK, NSString *_Nullable displayName) {
           FIRPhoneMultiFactorInfo* selectedHint;
           for (FIRMultiFactorInfo *tmpFactorInfo in resolver.hints) {
             if ([displayName isEqualToString:tmpFactorInfo.displayName]) {
               selectedHint = (FIRPhoneMultiFactorInfo *)tmpFactorInfo;
             }
           }
           [FIRPhoneAuthProvider.provider
            verifyPhoneNumberWithMultiFactorInfo:selectedHint
            UIDelegate:nil
            multiFactorSession:resolver.session
            completion:^(NSString * _Nullable verificationID, NSError * _Nullable error) {
              if (error) {
                [self showMessagePrompt:error.localizedDescription];
              } else {
                [self showTextInputPromptWithMessage:[NSString stringWithFormat:@"Verification code for %@", selectedHint.displayName]
                                     completionBlock:^(BOOL userPressedOK, NSString *_Nullable verificationCode) {
                 FIRPhoneAuthCredential *credential =
                     [[FIRPhoneAuthProvider provider] credentialWithVerificationID:verificationID
                                                                  verificationCode:verificationCode];
                 FIRMultiFactorAssertion *assertion = [FIRPhoneMultiFactorGenerator assertionWithCredential:credential];
                 [resolver resolveSignInWithAssertion:assertion completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
                   if (error) {
                     [self showMessagePrompt:error.localizedDescription];
                   } else {
                     NSLog(@"Multi factor finanlize sign in succeeded.");
                   }
                 }];
               }];
              }
            }];
         }];
        }
      else if (error) {
        // ...
        return;
      }
      // User successfully signed in. Get user data from the FIRUser object
      if (authResult == nil) { return; }
      FIRUser *user = authResult.user;
      // ...
    }];

Przetestuj z fikcyjnymi numerami telefonów

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

  • Przetestuj uwierzytelnianie numeru telefonu bez zużywania limitu wykorzystania.
  • Przetestuj uwierzytelnianie numeru telefonu bez wysyłania wiadomości SMS.
  • Przeprowadzaj kolejne testy z tym samym numerem telefonu, nie ulegając ograniczeniom. Minimalizuje to ryzyko odrzucenia podczas procesu recenzji w App Store, jeśli recenzent użyje tego samego numeru telefonu do testów.
  • Możliwość łatwego testowania w środowiskach programistycznych bez dodatkowego wysiłku, takiego jak możliwość programowania w symulatorze iOS lub emulatorze Androida bez Usług Google Play.
  • Pisz testy integracyjne bez blokowania przez kontrole bezpieczeństwa zwykle stosowane w przypadku rzeczywistych numerów telefonów w środowisku produkcyjnym.

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

  1. Upewnij się, że używasz numerów telefonów, które rzeczywiście są fikcyjne i jeszcze nie istnieją. Uwierzytelnianie Firebase nie pozwala na ustawienie istniejących numerów telefonów używanych przez prawdziwych użytkowników jako numerów testowych. Jedną z opcji jest użycie numerów 555 z prefiksem jako testowych numerów telefonów w USA, na przykład: +1 650-555-3434
  2. Numery telefonów muszą być poprawnie sformatowane pod kątem długości i innych ograniczeń. Nadal będą przechodzić tę samą weryfikację, co numer telefonu prawdziwego użytkownika.
  3. Możesz dodać do 10 numerów telefonów do celów rozwoju.
  4. Używaj testowych numerów telefonów/kodów, które są trudne do odgadnięcia i często je zmieniaj.

Twórz fikcyjne numery telefonów i kody weryfikacyjne

  1. W konsoli Firebase otwórz sekcję Uwierzytelnianie .
  2. Na karcie Metoda logowania włącz opcję Dostawca 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. Jeśli zajdzie taka potrzeba, możesz usunąć numer telefonu i jego kod, najeżdżając kursorem na odpowiedni wiersz i klikając ikonę kosza.

Testowanie ręczne

Możesz od razu zacząć używać fikcyjnego numeru telefonu w swojej aplikacji. Umożliwia to przeprowadzanie testów ręcznych na etapach programowania bez problemów z przydziałami i ograniczaniem przepustowości. Możesz także testować bezpośrednio z symulatora iOS lub emulatora Androida bez zainstalowanych Usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, żadna wiadomość SMS nie zostanie wysłana. Zamiast tego musisz podać wcześniej skonfigurowany kod weryfikacyjny, aby dokończyć logowanie.

Po zakończeniu logowania tworzony jest użytkownik Firebase z tym numerem telefonu. Użytkownik ma takie same właściwości i zachowanie jak użytkownik prawdziwego numeru telefonu i może uzyskać dostęp do bazy danych Realtime/Cloud Firestore i innych usług w ten sam sposób. Token identyfikacyjny wybity podczas tego procesu ma taki sam podpis, jak użytkownik prawdziwego numeru telefonu.

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

Testy integracyjne

Oprócz testów ręcznych, uwierzytelnianie Firebase udostępnia interfejsy API, które pomagają pisać testy integracyjne na potrzeby testowania uwierzytelniania telefonicznego. Te interfejsy API wyłączają weryfikację aplikacji, wyłączając wymaganie reCAPTCHA w powiadomieniach internetowych i cichych powiadomieniach push w systemie iOS. Dzięki temu możliwe jest testowanie automatyczne w tych przepływach i łatwiejsze do wdrożenia. Ponadto pomagają zapewnić możliwość testowania natychmiastowych procesów weryfikacji na Androidzie.

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

Pamiętaj, że jeśli weryfikacja aplikacji jest wyłączona, użycie niefikcyjnego numeru telefonu nie umożliwi dokończenia logowania. W tym interfejsie API można używać wyłącznie fikcyjnych numerów telefonów.

Szybki

let phoneNumber = "+16505554567"

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

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

Cel C

NSString *phoneNumber = @"+16505554567";

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

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

Dodatek: Korzystanie z logowania za pomocą telefonu bez konieczności przełączania

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

Jeśli nie chcesz używać swizzlingu, możesz go wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled do pliku Info.plist aplikacji i ustawiając ją na NO . Należy pamiętać, że ustawienie tej flagi na NO powoduje również wyłączenie przełączania dla innych produktów Firebase, w tym Firebase Cloud Messaging.

Jeśli wyłączysz swizzling, musisz jawnie przekazać token urządzenia APNs, powiadomienia push i adres URL przekierowania schematu niestandardowego do uwierzytelniania Firebase.

Jeśli tworzysz aplikację SwiftUI, powinieneś również jawnie przekazać token urządzenia APNs, powiadomienia push i adres URL przekierowania schematu niestandardowego do uwierzytelniania Firebase.

Aby uzyskać token urządzenia APNs należy zaimplementować metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:) i w niej przekazać token urządzenia do metody setAPNSToken(_:type:) Auth .

Szybki

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

  // Further handling of the device token if needed by the app
  // ...
}

Cel C

- (void)application:(UIApplication *)application
    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
  // Pass device token to auth.
  [[FIRAuth auth] setAPNSToken:deviceToken type:FIRAuthAPNSTokenTypeProd];
  // Further handling of the device token if needed by the app.
}

Aby obsłużyć powiadomienia push, w application(_:didReceiveRemoteNotification:fetchCompletionHandler:): sprawdź powiadomienia związane z uwierzytelnianiem Firebase, wywołując metodę canHandleNotification(_:) Auth .

Szybki

func application(_ application: UIApplication,
    didReceiveRemoteNotification notification: [AnyHashable : Any],
    fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
  if Auth.auth().canHandleNotification(notification) {
    completionHandler(.noData)
    return
  }
  // This notification is not auth related; it should be handled separately.
}

Cel C

- (void)application:(UIApplication *)application
    didReceiveRemoteNotification:(NSDictionary *)notification
          fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
  // Pass notification to auth and check if they can handle it.
  if ([[FIRAuth auth] canHandleNotification:notification]) {
    completionHandler(UIBackgroundFetchResultNoData);
    return;
  }
  // This notification is not auth related; it should be handled separately.
}

Aby obsłużyć niestandardowy adres URL przekierowania schematu, zaimplementuj metodę application(_:open:options:) i w nich przekaż adres URL do metody canHandleURL(_:) Auth .

Szybki

func application(_ application: UIApplication, open url: URL,
    options: [UIApplicationOpenURLOptionsKey : Any]) -> Bool {
  if Auth.auth().canHandle(url) {
    return true
  }
  // URL not auth related; it should be handled separately.
}

Cel C

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

Jeśli używasz SwiftUI lub UISceneDelegate , do obsługi adresu URL przekierowania zaimplementuj metodę scene(_:openURLContexts:) i w nich przekaż adres URL do metody canHandleURL(_:) Auth .

Szybki

func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
  for urlContext in URLContexts {
      let url = urlContext.url
      Auth.auth().canHandle(url)
  }
  // URL not auth related; it should be handled separately.
}

Cel C

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

Następne kroki

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

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

  • W regułach bezpieczeństwa bazy danych Firebase Realtime i Cloud Storage możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik może uzyskać dostęp.

Możesz zezwolić użytkownikom na logowanie się do aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.

Aby wylogować użytkownika, wywołaj funkcję signOut: .

Szybki

let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}

Cel C

NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

Możesz także dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Zobacz Błędy obsługi .