Join us in person and online for Firebase Summit on October 18, 2022. Learn how Firebase can help you accelerate app development, release your app with confidence, and scale with ease. Register now

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

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

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.

Najłatwiejszym sposobem dodania logowania za pomocą numeru telefonu do aplikacji jest użycie FirebaseUI , który obejmuje widżet logowania typu drop-in, który implementuje przepływy logowania dla logowania za pomocą numeru telefonu, a także logowanie oparte na hasłach i sfederowane -w. W tym dokumencie opisano, jak zaimplementować proces logowania za pomocą numeru telefonu przy użyciu pakietu Firebase SDK.

Zanim zaczniesz

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

  1. W Xcode przy otwartym projekcie aplikacji przejdź do pliku > Dodaj pakiety .
  2. Po wyświetleniu monitu dodaj repozytorium SDK platformy Firebase Apple:
  3.   https://github.com/firebase/firebase-ios-sdk
  4. Wybierz bibliotekę Uwierzytelniania Firebase.
  5. Po zakończeniu Xcode automatycznie rozpocznie rozwiązywanie i pobieranie zależności w tle.
I sprawdź krok konfiguracji:
  1. Jeśli aplikacja nie została jeszcze połączona 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ć 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ć go 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ę Uwierzytelnianie .
  2. Na stronie Metoda logowania włącz metodę logowania za pomocą numeru 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 cennik .

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:

  • Ciche powiadomienia APNs : gdy po raz pierwszy logujesz użytkownika przy użyciu jego numeru telefonu na urządzeniu, Uwierzytelnianie Firebase wysyła token na urządzenie, korzystając z cichego powiadomienia push. 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 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 używa weryfikacji reCAPTCHA do ukończenia telefonu 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łącz powiadomienia push dla swojego projektu.
  2. Prześlij swój klucz uwierzytelniania APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APNs, utwórz go w Apple Developer Member Center .

    1. Wewnątrz projektu w konsoli Firebase wybierz ikonę koła zębatego, wybierz Ustawienia projektu , a następnie wybierz kartę Wiadomości w chmurze .

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

    3. Przejdź do lokalizacji, w której zapisano klucz, wybierz go i kliknij Otwórz . Dodaj identyfikator klucza (dostępny w Apple Developer Member Center ) i kliknij Prześlij .

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

Skonfiguruj weryfikację reCAPTCHA

Aby umożliwić pakietowi Firebase SDK 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 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 twoja konfiguracja powinna wyglądać podobnie do poniższej (ale z wartościami specyficznymi dla aplikacji):

  2. Opcjonalne : jeśli chcesz dostosować sposób, w jaki aplikacja prezentuje SFSafariViewController podczas wyświetlania użytkownikowi reCAPTCHA, utwórz niestandardową klasę 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, zaprezentuj użytkownikowi interfejs z prośbą o podanie numeru telefonu, a następnie zadzwoń do verifyPhoneNumber(_:uiDelegate:completion:) , aby poprosić Firebase o wysłanie kodu uwierzytelniającego na telefon użytkownika SMS-em:

  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ń do verifyPhoneNumber(_:uiDelegate:completion:) , podając 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 wielodostępna: jeśli wywołasz ją wielokrotnie, na przykład w metodzie onAppear widoku, metoda verifyPhoneNumber nie wyśle ​​drugiego SMS-a, chyba że upłynął limit czasu pierwotnego żądania.

    Gdy dzwonisz do verifyPhoneNumber(_:uiDelegate:completion:) , Firebase wysyła do Twojej aplikacji ciche powiadomienie push lub wysyła użytkownikowi wyzwanie reCAPTCHA. 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ł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 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 obiektem 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 verifyPhoneNumber(_:uiDelegate:completion:) powiedzie się, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w wiadomości SMS.

Zaloguj się użytkownika za pomocą kodu weryfikacyjnego

Gdy użytkownik dostarczy aplikacji kod weryfikacyjny z wiadomości SMS, zaloguj się, tworząc obiekt FIRPhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacji, a następnie 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. Zaloguj się 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

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 numerów 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ń. 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ę Uwierzytelnianie .
  2. Na karcie Metoda logowania włącz dostawcę usług telefonicznych, 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 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ę tak samo 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.

Inną opcją jest ustawienie roli testowej za pomocą oświadczeń niestandardowych 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 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 iOS. Umożliwia to testowanie automatyzacji w tych przepływach i łatwiejsze do wdrożenia. Ponadto zapewniają możliwość testowania przepływów natychmiastowej weryfikacji w systemie Android.

W systemie iOS ustawienie appVerificationDisabledForTesting musi być ustawione 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 wolisz nie używać swizzlingu, możesz je wyłączyć, dodając flagę FirebaseAppDelegateProxyEnabled do pliku Info.plist aplikacji i ustawiając ją na NO . Pamiętaj, że ustawienie tej flagi na NO wyłącza również 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ć token urządzenia APNs, zaimplementuj metodę application(_:didRegisterForRemoteNotificationsWithDeviceToken:) i przekaż w niej token urządzenia do 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 metodzie 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ć adres URL przekierowania schematu niestandardowego, zaimplementuj metodę application(_:open:options:) i przekaż w nich 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 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 swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu FIRUser . Zobacz Zarządzanie użytkownikami .

  • W regułach bezpieczeństwa bazy danych czasu rzeczywistego i usługi Cloud Storage Firebase 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 Twojej 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 także dodać kod obsługi błędów dla pełnego zakresu błędów uwierzytelniania. Zobacz Obsługa błędów .