Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

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

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

Najłatwiejszym sposobem dodania logowania za pomocą numeru telefonu do aplikacji jest użycie FirebaseUI, który zawiera gotowy widżet logowania implementujący przepływy logowania za pomocą numeru telefonu, a także logowania za pomocą hasła i logowania sfederowanego. W tym dokumencie opisano, jak wdrożyć proces logowania się za pomocą numeru telefonu przy użyciu pakietu SDK Firebase.

Zanim zaczniesz

Jeśli aplikacja nie jest jeszcze połączona z projektem w Firebase, zrób to w konsoli Firebase.
Do instalowania zależności Firebase i zarządzania nimi używaj menedżera pakietów Swift.

Zapoznaj się z przewodnikiem instalacji, aby dowiedzieć się, jak dodać pakiety SDK Firebase do projektu Apple.
1. W Xcode, po otwarciu projektu aplikacji, kliknij File > Add Packages (Plik > Dodaj pakiety).
2. Gdy pojawi się prośba, dodaj repozytorium pakietu SDK Firebase na platformy Apple:
3. Wybierz bibliotekę Firebase Authentication.
4. Dodaj flagę -ObjC do sekcji Other Linker Flags (Inne flagi łączące) w ustawieniach kompilacji celu.
5. Gdy skończysz, Xcode zacznie automatycznie przetwarzać i pobierać zależności w tle.

Potencjalne problemy z bezpieczeństwem

Uwierzytelnianie za pomocą samego numeru telefonu, choć wygodne, jest mniej bezpieczne niż inne dostępne metody, ponieważ numer telefonu można łatwo przenieść między użytkownikami. Ponadto na urządzeniach z wieloma profilami użytkowników każdy użytkownik, który może odbierać SMS-y, może zalogować się na konto, używając numeru telefonu urządzenia.

Jeśli w aplikacji używasz logowania za pomocą numeru telefonu, udostępnij tę opcję obok bezpieczniejszych metod logowania i poinformuj użytkowników o kompromisach związanych z bezpieczeństwem, które wiążą się z używaniem numeru telefonu do logowania.

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

W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
Na karcie Metoda logowania włącz dostawcę logowania przez telefon.
Skonfiguruj zasadę dotyczącą regionów, do których chcesz zezwolić na wysyłanie SMS-ów lub zabronić ich wysyłania. Ustawienie zasad dotyczących regionów SMS-ów może pomóc chronić aplikacje przed nadużyciami związanymi z SMS-ami. W przypadku nowych projektów domyślna zasada nie zezwala na żadne regiony.
1. W konsoli Firebase otwórz kartę Zabezpieczenia > Uwierzytelnianie > Ustawienia.
2. W sekcji Zasady dotyczące regionów SMS skonfiguruj zasady dotyczące regionów SMS.

Włączanie weryfikacji aplikacji

Aby można było używać uwierzytelniania za pomocą numeru telefonu, Firebase musi mieć możliwość sprawdzenia, czy żądania logowania za pomocą numeru telefonu pochodzą z Twojej aplikacji. Firebase Authentication robi to na 2 sposoby:

Ciche powiadomienia APN: gdy użytkownik po raz pierwszy loguje się na urządzeniu przy użyciu swojego numeru telefonu, Firebase Authentication wysyła token na urządzenie za pomocą cichego powiadomienia push. Jeśli aplikacja pomyślnie odbierze powiadomienie z Firebase, będzie można kontynuować logowanie za pomocą numeru telefonu.
W przypadku iOS 8.0 i nowszych ciche powiadomienia nie wymagają wyraźnej zgody użytkownika, więc nie ma na nie wpływu odmowa otrzymywania powiadomień APN w aplikacji. Dlatego aplikacja nie musi prosić użytkownika o zgodę na otrzymywanie powiadomień push, gdy wdraża uwierzytelnianie numeru telefonu Firebase.
Weryfikacja reCAPTCHA: jeśli wysłanie lub odebranie cichego powiadomienia push jest niemożliwe, na przykład gdy użytkownik wyłączył odświeżanie w tle w aplikacji lub gdy testujesz aplikację w symulatorze iOS, Firebase Authentication używa weryfikacji reCAPTCHA, aby dokończyć proces logowania przez telefon. Zadanie reCAPTCHA często można wykonać bez konieczności rozwiązywania czegokolwiek przez użytkownika.

Jeśli ciche powiadomienia push są prawidłowo skonfigurowane, tylko niewielki odsetek użytkowników będzie musiał przejść przez proces reCAPTCHA. Niezależnie od tego, czy ciche powiadomienia push są dostępne, musisz upewnić się, że funkcja logowania za pomocą numeru telefonu działa prawidłowo.

Zacznij otrzymywać ciche powiadomienia

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

W Xcode włącz powiadomienia push w projekcie.
Prześlij klucz uwierzytelniania APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APNs, utwórz go w Apple Developer Member Center.
1. W konsoli Firebase kliknij Ustawienia > Ogólne. Następnie kliknij kartę Komunikacja w chmurze.
2. W sekcji Klucz uwierzytelniania APNs w obszarze Konfiguracja aplikacji na iOS kliknij Prześlij, aby przesłać klucz uwierzytelniania programistycznego lub produkcyjnego albo oba te klucze. Trzeba podać co najmniej 1 formę kontaktu.
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ć.
W Xcode włącz w projekcie funkcję trybów działania w tle, a następnie zaznacz pola wyboru trybów Pobieranie w tle i Powiadomienia zdalne.

Konfigurowanie weryfikacji reCAPTCHA

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

Dodaj niestandardowe schematy URI adresów URL do projektu Xcode:
1. Otwórz konfigurację projektu: kliknij dwukrotnie nazwę projektu w widoku drzewa po lewej stronie. Wybierz aplikację w sekcji TARGETS (Cele), a następnie kliknij kartę Info (Informacje) i rozwiń sekcję URL Types (Typy adresów URL).
2. Kliknij przycisk + i dodaj zakodowany identyfikator aplikacji jako schemat adresu URL. Pozostałe pola pozostaw puste.
  Zakodowany identyfikator aplikacji znajdziesz w konsoli Firebase: kliknij Ustawienia > karta Ogólne, a następnie przewiń w dół do sekcji Twoje aplikacje, aby wyświetlić szczegóły aplikacji na iOS.
  
  Po zakończeniu konfiguracja powinna wyglądać mniej więcej tak (ale z wartościami specyficznymi dla Twojej aplikacji):
Opcjonalnie: jeśli chcesz dostosować sposób, w jaki aplikacja prezentuje SFSafariViewController, gdy wyświetla użytkownikowi reCAPTCHA, utwórz klasę niestandardową zgodną z protokołem AuthUIDelegate i przekaż ją do verifyPhoneNumber(_:uiDelegate:completion:).

wysłać kod weryfikacyjny na telefon użytkownika,

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

Uzyskaj numer telefonu użytkownika.

Wymagania prawne różnią się, ale zgodnie ze sprawdzonymi metodami i aby określić oczekiwania użytkowników, poinformuj ich, że jeśli korzystają z logowania przez telefon, mogą otrzymać SMS-a z prośbą o weryfikację i że obowiązują standardowe opłaty.
Wywołaj verifyPhoneNumber(_:uiDelegate:completion:), przekazując numer telefonu użytkownika.
Swift
```
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
      // ...
  }
```
Objective-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
  // ...
}];
```
Uwaga: w zależności od abonamentu możesz mieć ograniczony dzienny limit wysyłanych SMS-ów. Zobacz Firebase Authentication Limity.

Metoda verifyPhoneNumber jest wielobieżna: jeśli wywołasz ją wielokrotnie, np. w metodzie onAppear widoku, metoda verifyPhoneNumber nie wyśle drugiego SMS-a, chyba że upłynie limit czasu pierwotnego żądania.

Gdy wywołasz verifyPhoneNumber(_:uiDelegate:completion:), Firebase wyśle do aplikacji ciche powiadomienie push lub wyświetli użytkownikowi zadanie reCAPTCHA. Gdy aplikacja otrzyma powiadomienie lub użytkownik ukończy zadanie reCAPTCHA, Firebase wysyła SMS-a z kodem uwierzytelniającym na podany numer telefonu i przekazuje identyfikator weryfikacyjny do funkcji zakończenia. Aby zalogować użytkownika, potrzebujesz zarówno kodu weryfikacyjnego, jak i identyfikatora weryfikacji.

Wiadomość SMS wysyłaną przez Firebase można też zlokalizować, określając język uwierzytelniania za pomocą właściwości languageCode w instancji Auth.
Swift
```
 // Change language code to french.
 Auth.auth().languageCode = "fr";
```
Objective-C
```
 // Change language code to french.
 [FIRAuth auth].languageCode = @"fr";
```
Zapisz identyfikator weryfikacji i przywróć go po załadowaniu aplikacji. Dzięki temu będziesz mieć pewność, że nadal masz ważny identyfikator weryfikacji, jeśli aplikacja zostanie zamknięta, zanim użytkownik zakończy proces logowania (np. podczas przełączania się na aplikację do SMS-ów).

Identyfikator weryfikacji możesz zachować w dowolny sposób. Prostym sposobem jest zapisanie identyfikatora weryfikacji w obiekcie NSUserDefaults:
Swift
```
UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
```
Objective-C
```
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
[defaults setObject:verificationID forKey:@"authVerificationID"];
```
Następnie możesz przywrócić zapisaną wartość:
Swift
```
let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
```
Objective-C
```
NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
```

Jeśli wywołanie verifyPhoneNumber(_:uiDelegate:completion:) się powiedzie, możesz poprosić użytkownika o wpisanie kodu weryfikacyjnego, gdy otrzyma go w SMS-ie.

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

Uzyskaj kod weryfikacyjny od użytkownika.

Utwórz obiekt FIRPhoneAuthCredential na podstawie kodu weryfikacyjnego i identyfikatora weryfikacji.

Swift

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

Objective-C

FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
    credentialWithVerificationID:verificationID
                verificationCode:userInput];

Zaloguj użytkownika za pomocą obiektu FIRPhoneAuthCredential:

Swift

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

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

Testowanie za pomocą fikcyjnych numerów telefonów

Możesz skonfigurować fikcyjne numery telefonów do celów programistycznych za pomocą konsoli Firebase. Testowanie z użyciem fikcyjnych numerów telefonów zapewnia te korzyści:

Przetestuj uwierzytelnianie numeru telefonu bez wykorzystywania limitu wykorzystania.
Przetestuj uwierzytelnianie numeru telefonu bez wysyłania SMS-a.
przeprowadzać kolejne testy z tym samym numerem telefonu bez ograniczania przepustowości. Zminimalizuje to ryzyko odrzucenia aplikacji podczas procesu sprawdzania w sklepie z aplikacjami, jeśli weryfikator użyje tego samego numeru telefonu do testów.
łatwe testowanie w środowiskach programistycznych bez dodatkowego wysiłku, np. możliwość programowania w symulatorze iOS lub Android Emulatorze bez usług Google Play;
pisać testy integracyjne bez blokowania przez kontrole bezpieczeństwa, które zwykle są stosowane do prawdziwych numerów telefonów w środowisku produkcyjnym;

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

Upewnij się, że używasz numerów telefonów, które są rzeczywiście fikcyjne i nie istnieją. Firebase Authentication nie pozwala na ustawianie 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 z prefiksem 555 jako amerykańskich testowych numerów telefonów, na przykład: +1 650-555-3434
Numery telefonów muszą być prawidłowo sformatowane pod względem długości i innych ograniczeń. Będą one przechodzić tę samą weryfikację co numer telefonu prawdziwego użytkownika.
Możesz dodać maksymalnie 10 numerów telefonów do celów programistycznych.
Używaj testowych numerów telefonów i kodów, które są trudne do odgadnięcia, i często je zmieniaj.

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

W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
Na karcie Metoda logowania włącz dostawcę logowania Telefon, jeśli nie został jeszcze włączony.
Rozwiń sekcję Numery telefonów do testowania.
Podaj numer telefonu, który chcesz przetestować, na przykład: +1 650-555-3434.
Podaj 6-cyfrowy kod weryfikacyjny dla tego konkretnego numeru, na przykład: 654321.
Kliknij Dodaj przy każdym numerze. W razie potrzeby możesz usunąć numer telefonu i jego kod, najeżdżając kursorem na odpowiedni wiersz i klikając ikonę kosza.

Testy ręczne

Możesz od razu zacząć używać fikcyjnego numeru telefonu w aplikacji. Dzięki temu możesz przeprowadzać testy ręczne na etapach programowania bez problemów z limitami i ograniczeniami. Możesz też przeprowadzić test bezpośrednio w symulatorze iOS lub Android Emulatorze bez zainstalowanych usług Google Play.

Gdy podasz fikcyjny numer telefonu i wyślesz kod weryfikacyjny, nie zostanie wysłany żaden SMS. 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 zachowania i właściwości jak użytkownik z prawdziwym numerem telefonu i może uzyskać dostęp do Realtime Database/Cloud Firestore i innych usług w ten sam sposób. Token identyfikacji wygenerowany podczas tego procesu ma taki sam podpis jak token prawdziwego użytkownika numeru telefonu.

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

Testy integracji

Oprócz testowania ręcznego Firebase Authentication udostępnia interfejsy API, które pomagają pisać testy integracyjne na potrzeby testowania uwierzytelniania przez telefon. Te interfejsy API wyłączają weryfikację aplikacji przez wyłączenie wymogu reCAPTCHA w przypadku powiadomień push w internecie i cichych powiadomień push w iOS. Umożliwia to testowanie automatyzacji w tych procesach i ułatwia ich wdrażanie. Dodatkowo pomagają testować procesy natychmiastowej weryfikacji na Androidzie.

W systemie iOS ustawienie appVerificationDisabledForTesting musi mieć wartość TRUE przed wywołaniem verifyPhoneNumber. Jest to przetwarzane bez konieczności użycia tokena APNs ani wysyłania cichych powiadomień push w tle, co ułatwia testowanie w symulatorze. Spowoduje to również wyłączenie procesu zastępczego reCAPTCHA.

Pamiętaj, że gdy weryfikacja aplikacji jest wyłączona, użycie prawdziwego numeru telefonu uniemożliwi ukończenie logowania. Z tym interfejsem API można używać tylko fikcyjnych numerów telefonów.

Swift

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 let error = error {
      // Handles error
      self.handleError(error)
      return
    }
    let credential = PhoneAuthProvider.provider().credential(withVerificationID: verificationID ?? "",
                                                               verificationCode: testVerificationCode)
    Auth.auth().signIn(with: credential) { authResult, error in
      if let error = error {
        // Handles error
        self.handleError(error)
        return
      }
      _user = authResult.user
    };
};

Objective-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;
    }];
}];

Firebase Authentication używa podmiany metody, aby automatycznie uzyskać token APNs aplikacji, obsługiwać ciche powiadomienia push wysyłane przez Firebase do 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. Pamiętaj, że ustawienie tej flagi na NO wyłącza też swizzling w innych usługach Firebase, w tym Firebase Cloud Messaging.

Jeśli wyłączysz swizzling, musisz bezpośrednio przekazać do Firebase Authentication token urządzenia APNs, powiadomienia push i niestandardowy schemat przekierowania adresu URL.

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

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

Uwaga: aplikacje SwiftUI powinny używać opakowań właściwości UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor, aby udostępniać typ odpowiadający odpowiedniemu protokołowi delegata aplikacji.

Swift

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

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

Objective-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ługiwać powiadomienia push, w metodzie application(_:didReceiveRemoteNotification:fetchCompletionHandler:): sprawdź powiadomienia związane z uwierzytelnianiem Firebase, wywołując metodę canHandleNotification(_:) klasy Auth.

Swift

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

Objective-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 niestandardowego schematu, wdróż metodę application(_:open:options:) i przekaż w niej adres URL do metody canHandleURL(_:) klasy Auth.

Swift

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

Objective-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, aby obsłużyć adres URL przekierowania, zaimplementuj metodę scene(_:openURLContexts:) i przekaż w niej adres URL do metody canHandleURL(_:) interfejsu Auth.

Swift

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

Objective-C

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

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z danymi logowania, czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania, których użytkownik użył do zalogowania się. To nowe konto jest przechowywane w projekcie w Firebase i może służyć do identyfikowania użytkownika we wszystkich aplikacjach w projekcie, niezależnie od tego, jak się loguje.

W aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu User . Zobacz Zarządzanie użytkownikami.
W Firebase Realtime Database i Cloud Storage regułach zabezpieczeń możesz pobrać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.

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

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

Swift

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

Objective-C

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

Możesz też dodać kod obsługi błędów dla wszystkich błędów uwierzytelniania. Zobacz Obsługa błędów.

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

Zanim zaczniesz

Potencjalne problemy z bezpieczeństwem

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

Włączanie weryfikacji aplikacji

Zacznij otrzymywać ciche powiadomienia

Konfigurowanie weryfikacji reCAPTCHA

wysłać kod weryfikacyjny na telefon użytkownika,

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Logowanie użytkownika za pomocą kodu weryfikacyjnego

Swift

Objective-C

Swift

Objective-C

Testowanie za pomocą fikcyjnych numerów telefonów

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

Testy ręczne

Testy integracji

Swift

Objective-C

Dodatek: korzystanie z logowania się za pomocą telefonu bez swizzlingu

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Dalsze kroki

Swift

Objective-C

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