Authentifizieren Sie sich bei Firebase auf Apple-Plattformen mithilfe einer Telefonnummer

Sie können die Firebase-Authentifizierung verwenden, um einen Benutzer anzumelden, indem Sie eine SMS-Nachricht an das Telefon des Benutzers senden. Der Benutzer meldet sich mit einem Einmalcode an, der in der SMS-Nachricht enthalten ist.

Der einfachste Weg, die Telefonnummernanmeldung zu Ihrer App hinzuzufügen, ist die Verwendung von FirebaseUI , das ein Drop-in-Anmelde-Widget enthält, das Anmeldeabläufe für die Telefonnummernanmeldung sowie passwortbasierte und föderierte Anmeldungen implementiert -In. In diesem Dokument wird beschrieben, wie Sie mit dem Firebase SDK einen Anmeldevorgang für Telefonnummern implementieren.

Bevor Sie beginnen

Verwenden Sie Swift Package Manager, um Firebase-Abhängigkeiten zu installieren und zu verwalten.

  1. Navigieren Sie in Xcode bei geöffnetem App-Projekt zu File > Add Packages .
  2. Wenn Sie dazu aufgefordert werden, fügen Sie das Firebase Apple Platforms SDK-Repository hinzu:
  3.   https://github.com/firebase/firebase-ios-sdk.git
  4. Wählen Sie die Firebase Authentication-Bibliothek.
  5. Fügen Sie das Flag -ObjC zum Abschnitt „Andere Linker-Flags“ der Build-Einstellungen Ihres Ziels hinzu.
  6. Wenn Sie fertig sind, beginnt Xcode automatisch mit der Auflösung und dem Herunterladen Ihrer Abhängigkeiten im Hintergrund.
Und überprüfen Sie einen Konfigurationsschritt:
  1. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verbunden haben, tun Sie dies über die Firebase-Konsole .

Sicherheitsbedenken

Die Authentifizierung nur mit einer Telefonnummer ist zwar praktisch, aber weniger sicher als die anderen verfügbaren Methoden, da der Besitz einer Telefonnummer leicht zwischen Benutzern übertragen werden kann. Außerdem kann sich auf Geräten mit mehreren Benutzerprofilen jeder Benutzer, der SMS-Nachrichten empfangen kann, mit der Telefonnummer des Geräts bei einem Konto anmelden.

Wenn Sie in Ihrer App die auf Telefonnummern basierende Anmeldung verwenden, sollten Sie diese zusammen mit sichereren Anmeldemethoden anbieten und Benutzer über die Sicherheitsabstriche bei der Verwendung der Telefonnummernanmeldung informieren.

Aktivieren Sie die Anmeldung per Telefonnummer für Ihr Firebase-Projekt

Um Benutzer per SMS anzumelden, müssen Sie zunächst die Anmeldemethode „Telefonnummer“ für Ihr Firebase-Projekt aktivieren:

  1. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung .
  2. Aktivieren Sie auf der Seite „Anmeldemethode“ die Anmeldemethode „Telefonnummer“ .

Das Kontingent von Firebase-Anmeldeanfragen für Telefonnummern ist hoch genug, dass die meisten Apps nicht betroffen sind. Wenn Sie jedoch eine sehr große Anzahl von Benutzern mit Telefonauthentifizierung anmelden müssen, müssen Sie möglicherweise Ihren Preisplan aktualisieren. Siehe Preisseite .

Aktivieren Sie die App-Verifizierung

Um die Telefonnummernauthentifizierung verwenden zu können, muss Firebase überprüfen können, ob Anmeldeanfragen für Telefonnummern von Ihrer App kommen. Dies kann mit der Firebase-Authentifizierung auf zwei Arten erreicht werden:

  • Stille APNs-Benachrichtigungen : Wenn Sie einen Benutzer zum ersten Mal mit seiner Telefonnummer auf einem Gerät anmelden, sendet die Firebase-Authentifizierung mithilfe einer stillen Push-Benachrichtigung ein Token an das Gerät. Wenn Ihre App die Benachrichtigung von Firebase erfolgreich empfängt, kann die Anmeldung über die Telefonnummer fortgesetzt werden.

    Für iOS 8.0 und neuer erfordern stille Benachrichtigungen keine ausdrückliche Zustimmung des Benutzers und sind daher nicht betroffen, wenn ein Benutzer den Empfang von APN-Benachrichtigungen in der App ablehnt. Daher muss die App bei der Implementierung der Firebase-Telefonnummernauthentifizierung keine Benutzerberechtigung für den Empfang von Push-Benachrichtigungen anfordern.

  • reCAPTCHA-Überprüfung : Für den Fall, dass das Senden oder Empfangen einer stillen Push-Benachrichtigung nicht möglich ist, z. B. wenn der Benutzer die Hintergrundaktualisierung für Ihre App deaktiviert hat oder wenn Sie Ihre App auf einem iOS-Simulator testen, verwendet die Firebase-Authentifizierung die reCAPTCHA-Überprüfung, um das Telefon zu vervollständigen Anmeldevorgang. Die reCAPTCHA-Challenge kann häufig abgeschlossen werden, ohne dass der Benutzer etwas lösen muss.

Wenn stille Push-Benachrichtigungen richtig konfiguriert sind, wird nur ein sehr kleiner Prozentsatz der Benutzer den reCAPTCHA-Fluss erleben. Dennoch sollten Sie sicherstellen, dass die Telefonnummernanmeldung ordnungsgemäß funktioniert, unabhängig davon, ob stille Push-Benachrichtigungen verfügbar sind oder nicht.

Erhalten Sie stille Benachrichtigungen

So aktivieren Sie APNs-Benachrichtigungen für die Verwendung mit Firebase-Authentifizierung:

  1. Aktivieren Sie in Xcode Push-Benachrichtigungen für Ihr Projekt.
  2. Laden Sie Ihren APNs-Authentifizierungsschlüssel auf Firebase hoch. Wenn Sie noch keinen APNs-Authentifizierungsschlüssel haben, erstellen Sie unbedingt einen im Apple Developer Member Center .

    1. Wählen Sie in Ihrem Projekt in der Firebase-Konsole das Zahnradsymbol aus, wählen Sie Projekteinstellungen und dann die Registerkarte Cloud-Messaging aus.

    2. Klicken Sie unter „APNs-Authentifizierungsschlüssel“ unter „iOS-App-Konfiguration“ auf die Schaltfläche „Hochladen“ .

    3. Navigieren Sie zu dem Speicherort, an dem Sie Ihren Schlüssel gespeichert haben, wählen Sie ihn aus und klicken Sie auf Öffnen . Fügen Sie die Schlüssel-ID für den Schlüssel hinzu (verfügbar im Apple Developer Member Center ) und klicken Sie auf Hochladen .

    Wenn Sie bereits über ein APNs-Zertifikat verfügen, können Sie stattdessen das Zertifikat hochladen.

Richten Sie die reCAPTCHA-Verifizierung ein

So aktivieren Sie das Firebase SDK für die Verwendung der reCAPTCHA-Überprüfung:

  1. Fügen Sie Ihrem Xcode-Projekt benutzerdefinierte URL-Schemata hinzu:
    1. Öffnen Sie Ihre Projektkonfiguration: Doppelklicken Sie auf den Projektnamen in der linken Baumansicht. Wählen Sie Ihre App im Abschnitt „ZIELE“ aus, wählen Sie dann die Registerkarte „Info“ aus und erweitern Sie den Abschnitt „URL-Typen“ .
    2. Klicken Sie auf die Schaltfläche „+“ und fügen Sie Ihre verschlüsselte App-ID als URL-Schema hinzu. Sie finden Ihre verschlüsselte App-ID auf der Seite „Allgemeine Einstellungen“ der Firebase-Konsole im Abschnitt für Ihre iOS-App. Lassen Sie die anderen Felder leer.

      Nach Abschluss sollte Ihre Konfiguration etwa wie folgt aussehen (jedoch mit Ihren anwendungsspezifischen Werten):

      Screenshot der benutzerdefinierten URL-Schema-Einrichtungsschnittstelle von Xcode
  2. Optional : Wenn Sie die Art und Weise anpassen möchten, wie Ihre App den SFSafariViewController darstellt, wenn sie dem Benutzer das reCAPTCHA anzeigt, erstellen Sie eine benutzerdefinierte Klasse, die dem AuthUIDelegate Protokoll entspricht, und übergeben Sie sie an verifyPhoneNumber(_:uiDelegate:completion:) .

Senden Sie einen Bestätigungscode an das Telefon des Benutzers

Um die Anmeldung über die Telefonnummer zu initiieren, präsentieren Sie dem Benutzer eine Schnittstelle, die ihn zur Angabe seiner Telefonnummer auffordert, und rufen Sie dann verifyPhoneNumber(_:uiDelegate:completion:) auf, um Firebase aufzufordern, einen Authentifizierungscode per SMS an das Telefon des Benutzers zu senden:

  1. Rufen Sie die Telefonnummer des Benutzers ab.

    Die rechtlichen Anforderungen variieren. Als Best Practice und um die Erwartungen Ihrer Benutzer zu wecken, sollten Sie sie jedoch darüber informieren, dass sie bei Verwendung der telefonischen Anmeldung möglicherweise eine SMS-Nachricht zur Überprüfung erhalten und Standardtarife gelten.

  2. Rufen Sie verifyPhoneNumber(_:uiDelegate:completion:) auf und übergeben Sie ihm die Telefonnummer des Benutzers.

    Schnell

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

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

    Die Methode verifyPhoneNumber ist wiedereintrittsfähig: Wenn Sie sie mehrmals aufrufen, beispielsweise in der Methode onAppear einer Ansicht, sendet die Methode „ verifyPhoneNumber “ keine zweite SMS, es sei denn, die ursprüngliche Anforderung ist abgelaufen.

    Wenn Sie verifyPhoneNumber(_:uiDelegate:completion:) aufrufen, sendet Firebase eine stille Push-Benachrichtigung an Ihre App oder stellt dem Benutzer eine reCAPTCHA-Aufforderung aus. Nachdem Ihre App die Benachrichtigung erhalten hat oder der Benutzer die reCAPTCHA-Herausforderung abgeschlossen hat, sendet Firebase eine SMS-Nachricht mit einem Authentifizierungscode an die angegebene Telefonnummer und übergibt eine Bestätigungs-ID an Ihre Abschlussfunktion. Sie benötigen sowohl den Bestätigungscode als auch die Bestätigungs-ID, um den Benutzer anzumelden.

    Die von Firebase gesendete SMS-Nachricht kann auch lokalisiert werden, indem Sie die Authentifizierungssprache über die languageCode Eigenschaft Ihrer Auth-Instanz angeben.

    Schnell

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

    Ziel c

     // Change language code to french.
     [FIRAuth auth].languageCode = @"fr";
    
  3. Speichern Sie die Verifizierungs-ID und stellen Sie sie wieder her, wenn Ihre App geladen wird. Auf diese Weise können Sie sicherstellen, dass Sie immer noch über eine gültige Verifizierungs-ID verfügen, wenn Ihre App beendet wird, bevor der Benutzer den Anmeldevorgang abschließt (z. B. beim Wechsel zur SMS-App).

    Sie können die Verifizierungs-ID beliebig beibehalten. Eine einfache Möglichkeit besteht darin, die Verifizierungs-ID mit dem NSUserDefaults -Objekt zu speichern:

    Schnell

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

    Ziel c

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

    Anschließend können Sie den gespeicherten Wert wiederherstellen:

    Schnell

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

    Ziel c

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

Wenn der Aufruf von verifyPhoneNumber(_:uiDelegate:completion:) erfolgreich ist, können Sie den Benutzer auffordern, den Bestätigungscode einzugeben, wenn er ihn in der SMS-Nachricht erhält.

Melden Sie den Benutzer mit dem Bestätigungscode an

Nachdem der Benutzer Ihrer App den Bestätigungscode aus der SMS-Nachricht bereitgestellt hat, melden Sie den Benutzer an, indem Sie aus dem Bestätigungscode und der Bestätigungs-ID ein FIRPhoneAuthCredential Objekt erstellen und dieses Objekt an signInWithCredential:completion: übergeben.

  1. Holen Sie sich den Bestätigungscode vom Benutzer.
  2. Erstellen Sie ein FIRPhoneAuthCredential Objekt aus dem Bestätigungscode und der Bestätigungs-ID.

    Schnell

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

    Ziel c

    FIRAuthCredential *credential = [[FIRPhoneAuthProvider provider]
        credentialWithVerificationID:verificationID
                    verificationCode:userInput];
  3. Melden Sie den Benutzer mit dem FIRPhoneAuthCredential -Objekt an:

    Schnell

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

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

Testen Sie mit fiktiven Telefonnummern

Über die Firebase-Konsole können Sie fiktive Telefonnummern für die Entwicklung einrichten. Das Testen mit fiktiven Telefonnummern bietet folgende Vorteile:

  • Testen Sie die Authentifizierung Ihrer Telefonnummer, ohne Ihr Nutzungskontingent zu verbrauchen.
  • Testen Sie die Authentifizierung der Telefonnummer, ohne eine tatsächliche SMS-Nachricht zu senden.
  • Führen Sie aufeinanderfolgende Tests mit derselben Telefonnummer durch, ohne dass es zu einer Drosselung kommt. Dies minimiert das Risiko einer Ablehnung während des Überprüfungsprozesses im App Store, wenn der Prüfer zufällig dieselbe Telefonnummer zum Testen verwendet.
  • Testen Sie problemlos in Entwicklungsumgebungen ohne zusätzlichen Aufwand, z. B. die Möglichkeit, in einem iOS-Simulator oder einem Android-Emulator ohne Google Play Services zu entwickeln.
  • Schreiben Sie Integrationstests, ohne durch Sicherheitsüberprüfungen blockiert zu werden, die normalerweise auf echte Telefonnummern in einer Produktionsumgebung angewendet werden.

Fiktive Telefonnummern müssen diese Anforderungen erfüllen:

  1. Stellen Sie sicher, dass Sie Telefonnummern verwenden, die tatsächlich fiktiv sind und noch nicht existieren. Mit der Firebase-Authentifizierung können Sie vorhandene Telefonnummern, die von echten Benutzern verwendet werden, nicht als Testnummern festlegen. Eine Möglichkeit besteht darin, 555-Vorwahlnummern als US-Testtelefonnummern zu verwenden, zum Beispiel: +1 650-555-3434
  2. Telefonnummern müssen im Hinblick auf Länge und andere Einschränkungen korrekt formatiert sein. Sie durchlaufen weiterhin die gleiche Validierung wie die Telefonnummer eines echten Benutzers.
  3. Sie können bis zu 10 Telefonnummern für die Entwicklung hinzufügen.
  4. Verwenden Sie Testtelefonnummern/-codes, die schwer zu erraten sind, und ändern Sie diese häufig.

Erstellen Sie fiktive Telefonnummern und Bestätigungscodes

  1. Öffnen Sie in der Firebase-Konsole den Abschnitt Authentifizierung .
  2. Aktivieren Sie auf der Registerkarte „Anmeldemethode“ den Telefonanbieter, falls Sie dies noch nicht getan haben.
  3. Öffnen Sie das Menü Telefonnummern zum Testen des Akkordeons.
  4. Geben Sie die Telefonnummer an, die Sie testen möchten, zum Beispiel: +1 650-555-3434 .
  5. Geben Sie den 6-stelligen Bestätigungscode für diese bestimmte Nummer an, zum Beispiel: 654321 .
  6. Fügen Sie die Nummer hinzu. Bei Bedarf können Sie die Telefonnummer und ihren Code löschen, indem Sie mit der Maus über die entsprechende Zeile fahren und auf das Papierkorbsymbol klicken.

Manuelles Testen

Sie können direkt damit beginnen, eine fiktive Telefonnummer in Ihrer Bewerbung zu verwenden. Dadurch können Sie während der Entwicklungsphase manuelle Tests durchführen, ohne dass es zu Kontingentproblemen oder Drosselungen kommt. Sie können den Test auch direkt von einem iOS-Simulator oder Android-Emulator aus durchführen, ohne dass Google Play Services installiert ist.

Wenn Sie die fiktive Telefonnummer angeben und den Bestätigungscode senden, wird keine tatsächliche SMS gesendet. Stattdessen müssen Sie den zuvor konfigurierten Bestätigungscode angeben, um die Anmeldung abzuschließen.

Nach Abschluss der Anmeldung wird ein Firebase-Benutzer mit dieser Telefonnummer erstellt. Der Benutzer hat das gleiche Verhalten und die gleichen Eigenschaften wie ein echter Telefonnummernbenutzer und kann auf die gleiche Weise auf Realtime Database/Cloud Firestore und andere Dienste zugreifen. Der während dieses Vorgangs geprägte ID-Token hat die gleiche Signatur wie ein echter Telefonnummernbenutzer.

Eine andere Möglichkeit besteht darin , über benutzerdefinierte Ansprüche eine Testrolle für diese Benutzer festzulegen, um sie als gefälschte Benutzer zu differenzieren, wenn Sie den Zugriff weiter einschränken möchten.

Integrationstests

Zusätzlich zu manuellen Tests bietet Firebase Authentication APIs, die beim Schreiben von Integrationstests für Telefonauthentifizierungstests helfen. Diese APIs deaktivieren die App-Verifizierung, indem sie die reCAPTCHA-Anforderung im Web und stille Push-Benachrichtigungen in iOS deaktivieren. Dies macht Automatisierungstests in diesen Abläufen möglich und einfacher zu implementieren. Darüber hinaus bieten sie die Möglichkeit, sofortige Verifizierungsabläufe auf Android zu testen.

Unter iOS muss die Einstellung appVerificationDisabledForTesting auf TRUE gesetzt werden, bevor verifyPhoneNumber aufgerufen wird. Dies wird verarbeitet, ohne dass ein APNs-Token erforderlich ist oder stille Push-Benachrichtigungen im Hintergrund gesendet werden, was das Testen in einem Simulator erleichtert. Dadurch wird auch der reCAPTCHA-Fallback-Flow deaktiviert.

Beachten Sie, dass bei deaktivierter App-Verifizierung die Anmeldung mit einer nicht fiktiven Telefonnummer nicht abgeschlossen werden kann. Mit dieser API können nur fiktive Telefonnummern verwendet werden.

Schnell

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

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

Anhang: Telefonanmeldung ohne Swizzling verwenden

Die Firebase-Authentifizierung verwendet Methoden-Swizzling, um automatisch das APNs-Token Ihrer App abzurufen, die stillen Push-Benachrichtigungen zu verarbeiten, die Firebase an Ihre App sendet, und um die benutzerdefinierte Schemaumleitung von der reCAPTCHA-Überprüfungsseite während der Überprüfung automatisch abzufangen.

Wenn Sie Swizzling lieber nicht verwenden möchten, können Sie es deaktivieren, indem Sie das Flag FirebaseAppDelegateProxyEnabled zur Info.plist-Datei Ihrer App hinzufügen und es auf NO setzen. Beachten Sie, dass das Setzen dieses Flags auf NO auch das Swizzling für andere Firebase-Produkte, einschließlich Firebase Cloud Messaging, deaktiviert.

Wenn Sie Swizzling deaktivieren, müssen Sie das APNs-Gerätetoken, Push-Benachrichtigungen und die Umleitungs-URL des benutzerdefinierten Schemas explizit an Firebase Authentication übergeben.

Wenn Sie eine SwiftUI-Anwendung erstellen, sollten Sie auch das APNs-Gerätetoken, Push-Benachrichtigungen und die Umleitungs-URL des benutzerdefinierten Schemas explizit an Firebase Authentication übergeben.

Um das APNs-Gerätetoken zu erhalten, implementieren Sie die Methode application(_:didRegisterForRemoteNotificationsWithDeviceToken:) und übergeben Sie darin das Gerätetoken an die Methode setAPNSToken(_:type:) von Auth .

Schnell

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

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

Um Push-Benachrichtigungen zu verarbeiten, prüfen Sie in der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:): “ nach Firebase-Authentifizierungsbenachrichtigungen, indem Sie die Methode canHandleNotification(_:) von Auth aufrufen.

Schnell

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

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

Um die Umleitungs-URL des benutzerdefinierten Schemas zu verarbeiten, implementieren Sie die Methode application(_:open:options:) und übergeben Sie darin die URL an die Methode canHandleURL(_:) von Auth .

Schnell

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

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

Wenn Sie SwiftUI oder UISceneDelegate verwenden, implementieren Sie zur Verarbeitung der Umleitungs-URL die Methode scene(_:openURLContexts:) und übergeben Sie darin die URL an die Methode canHandleURL(_:) von Auth .

Schnell

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

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

Nächste Schritte

Nachdem sich ein Benutzer zum ersten Mal angemeldet hat, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen – also dem Benutzernamen und dem Kennwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter – verknüpft, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann zur Identifizierung eines Benutzers in jeder App in Ihrem Projekt verwendet werden, unabhängig davon, wie sich der Benutzer anmeldet.

  • In Ihren Apps können Sie die grundlegenden Profilinformationen des Benutzers aus dem User Objekt abrufen. Siehe Benutzer verwalten .

  • In Ihren Firebase-Echtzeitdatenbank- und Cloud-Speicher- Sicherheitsregeln können Sie die eindeutige Benutzer-ID des angemeldeten Benutzers aus der auth abrufen und damit steuern, auf welche Daten ein Benutzer zugreifen kann.

Sie können Benutzern ermöglichen, sich mit mehreren Authentifizierungsanbietern bei Ihrer App anzumelden, indem Sie die Anmeldeinformationen des Authentifizierungsanbieters mit einem vorhandenen Benutzerkonto verknüpfen.

Um einen Benutzer abzumelden, rufen Sie signOut: auf.

Schnell

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

Ziel c

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

Möglicherweise möchten Sie auch Fehlerbehandlungscode für alle Authentifizierungsfehler hinzufügen. Siehe Fehler behandeln .