Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Mit einer Telefonnummer bei Firebase auf Apple-Plattformen authentifizieren

Sie können Firebase Authentication verwenden, um einen Nutzer anzumelden, indem Sie eine SMS an das Smartphone des Nutzers senden. Der Nutzer meldet sich mit einem Einmalcode an, der in der SMS enthalten ist.

Die einfachste Möglichkeit, die Anmeldung per Telefonnummer in Ihre App einzubinden, ist die Verwendung von FirebaseUI. FirebaseUI enthält ein Drop-in-Anmelde-Widget, das Anmeldeabläufe für die Anmeldung per Telefonnummer sowie für die passwortbasierte und föderierte Anmeldung implementiert. In diesem Dokument wird beschrieben, wie Sie einen Anmeldevorgang mit einer Telefonnummer mithilfe des Firebase SDK implementieren.

Hinweis

Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verbunden haben, können Sie das in der Firebase-Konsole tun.
Verwenden Sie Swift Package Manager, um Firebase-Abhängigkeiten zu installieren und zu verwalten.

In unserer Installationsanleitung finden Sie Informationen zu den verschiedenen Möglichkeiten, wie Sie Firebase SDKs zu Ihrem Apple-Projekt hinzufügen können.
1. Öffnen Sie Ihr App-Projekt und gehen Sie in Xcode zu File > Add Packages (Datei > Pakete hinzufügen).
2. Fügen Sie bei entsprechender Aufforderung das Firebase Apple Platforms SDK-Repository hinzu:
3. Wählen Sie die Bibliothek Firebase Authentication aus.
4. Fügen Sie das Flag -ObjC im Bereich Other Linker Flags (Andere Linker-Flags) der Build-Einstellungen Ihres Ziels hinzu.
5. Wenn Sie fertig, beginnt Xcode automatisch, Ihre Abhängigkeiten im Hintergrund aufzulösen und herunterzuladen.

Sicherheitsbedenken

Die Authentifizierung nur mit einer Telefonnummer ist zwar praktisch, aber weniger sicher als die anderen verfügbaren Methoden, da die Inhaberschaft einer Telefonnummer leicht zwischen Nutzern übertragen werden kann. Auf Geräten mit mehreren Nutzerprofilen kann sich jeder Nutzer, der SMS empfangen kann, mit der Telefonnummer des Geräts in einem Konto anmelden.

Wenn Sie in Ihrer App die Anmeldung per Telefonnummer verwenden, sollten Sie sie zusammen mit sichereren Anmeldemethoden anbieten und Nutzer über die Sicherheitsrisiken der Anmeldung per Telefonnummer informieren.

Wenn Sie Nutzer per SMS anmelden möchten, müssen Sie zuerst die Anmeldemethode „Telefonnummer“ für Ihr Firebase-Projekt aktivieren:

Rufen Sie in der Firebase-Konsole Sicherheit > Authentifizierung auf.
Aktivieren Sie auf dem Tab Anmeldemethode den Anbieter für die Anmeldung über Telefon.
Legen Sie eine Richtlinie für die Regionen fest, in die SMS gesendet werden dürfen oder nicht. Durch das Festlegen einer SMS-Regionsrichtlinie können Sie Ihre Apps besser vor SMS-Missbrauch schützen. Bei neuen Projekten sind in der Standardrichtlinie keine Regionen zulässig.
1. Rufen Sie in der Firebase-Konsole den Tab Sicherheit > Authentifizierung > Einstellungen auf.
2. Richten Sie im Bereich Richtlinie für SMS-Regionen die Richtlinie für SMS-Regionen ein.

App-Überprüfung aktivieren

Damit die Authentifizierung per Telefonnummer verwendet werden kann, muss Firebase prüfen können, ob die Anfragen zur Anmeldung per Telefonnummer von Ihrer App stammen. Firebase Authentication erreicht dies auf zwei Arten:

Stille APNs-Benachrichtigungen: Wenn Sie einen Nutzer zum ersten Mal mit seiner Telefonnummer auf einem Gerät anmelden, sendet Firebase Authentication ein Token über eine stille Push-Benachrichtigung an das Gerät. Wenn Ihre App die Benachrichtigung von Firebase erfolgreich empfängt, kann die Anmeldung per Telefonnummer fortgesetzt werden.
Für iOS 8.0 und höher ist für stille Benachrichtigungen keine ausdrückliche Nutzereinwilligung erforderlich. Sie sind daher nicht davon betroffen, wenn ein Nutzer den Empfang von APNs-Benachrichtigungen in der App ablehnt. Die App muss also keine Nutzerberechtigung zum Empfang von Push-Benachrichtigungen anfordern, wenn die Firebase-Telefonnummernauthentifizierung implementiert wird.
reCAPTCHA-Überprüfung: Wenn das Senden oder Empfangen einer stillen Push-Benachrichtigung nicht möglich ist, z. B. wenn der Nutzer die Hintergrundaktualisierung für Ihre App deaktiviert hat oder wenn Sie Ihre App in einem iOS-Simulator testen, verwendet Firebase Authentication die reCAPTCHA-Überprüfung, um die Anmeldung per Telefon abzuschließen. Die reCAPTCHA-Aufgabe kann oft abgeschlossen werden, ohne dass der Nutzer etwas lösen muss.

Wenn lautlose Push-Benachrichtigungen richtig konfiguriert sind, wird der reCAPTCHA-Vorgang nur für einen sehr kleinen Prozentsatz der Nutzer ausgeführt. Du solltest jedoch dafür sorgen, dass die Anmeldung per Telefonnummer unabhängig davon, ob lautlose Push-Benachrichtigungen verfügbar sind, korrekt funktioniert.

Lautlose Benachrichtigungen erhalten

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

Aktivieren Sie in Xcode Push-Benachrichtigungen für Ihr Projekt.
Laden Sie Ihren APNs-Authentifizierungsschlüssel in Firebase hoch. Wenn Sie noch keinen APNs-Authentifizierungsschlüssel haben, erstellen Sie einen im Apple Developer Member Center.
1. Rufen Sie in der Firebase Console die Einstellungen > Allgemein auf. Klicken Sie dann auf den Tab Cloud Messaging.
2. Klicken Sie unter iOS-App-Konfiguration bei APNs-Authentifizierungsschlüssel auf Hochladen, um Ihren Entwicklungs-Authentifizierungsschlüssel, Ihren Produktions-Authentifizierungsschlüssel oder beide hochzuladen. Mindestens eine Angabe ist erforderlich.
3. Suchen Sie den 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 ein APNs-Zertifikat haben, können Sie stattdessen dieses Zertifikat hochladen.
Aktivieren Sie in Xcode die Funktion „Background Modes“ für Ihr Projekt und setzen Sie dann die Häkchen bei den Modi Background fetch und Remote notifications.

reCAPTCHA-Überprüfung einrichten

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

Fügen Sie Ihrem Xcode-Projekt benutzerdefinierte URL-Schemas hinzu:
1. Öffnen Sie Ihre Projektkonfiguration: Doppelklicken Sie in der linken Strukturansicht auf den Projektnamen. Wählen Sie im Bereich TARGETS Ihre App aus, wählen Sie dann den Tab Info aus und maximieren Sie den Bereich URL Types.
2. Klicken Sie auf das Pluszeichen (+) und fügen Sie die codierte App-ID als URL-Schema hinzu. Lassen Sie die anderen Felder leer.
  Sie finden Ihre codierte App-ID in der Firebase-Konsole: Gehen Sie zu den Einstellungen > Tab Allgemein und scrollen Sie dann nach unten zum Abschnitt Meine Apps, um Details zu Ihrer iOS-App aufzurufen.
  
  Wenn der Vorgang abgeschlossen ist, sollte Ihre Konfiguration in etwa so aussehen (jedoch mit Ihren anwendungsspezifischen Werten):
Optional: Wenn Sie die Darstellung des SFSafariViewController in Ihrer App anpassen möchten, wenn dem Nutzer das reCAPTCHA angezeigt wird, erstellen Sie eine benutzerdefinierte Klasse, die dem AuthUIDelegate-Protokoll entspricht, und übergeben Sie sie an verifyPhoneNumber(_:uiDelegate:completion:).

Bestätigungscode an das Smartphone des Nutzers senden

Wenn Sie die Anmeldung per Telefonnummer initiieren möchten, präsentieren Sie dem Nutzer eine Oberfläche, auf der er seine Telefonnummer eingeben muss. Rufen Sie dann verifyPhoneNumber(_:uiDelegate:completion:) auf, um Firebase aufzufordern, einen Authentifizierungscode per SMS an das Smartphone des Nutzers zu senden:

Telefonnummer des Nutzers abrufen

Die rechtlichen Anforderungen variieren. Als Best Practice und um die Erwartungen Ihrer Nutzer zu erfüllen, sollten Sie sie darüber informieren, dass sie bei der Anmeldung per Telefon möglicherweise eine SMS zur Bestätigung erhalten und dass Standardgebühren anfallen.
Rufen Sie verifyPhoneNumber(_:uiDelegate:completion:) auf und übergeben Sie die Telefonnummer des Nutzers.
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
  // ...
}];
```
Hinweis: Je nach Preismodell ist die Anzahl der SMS, die Sie pro Tag senden können, möglicherweise begrenzt. Weitere Informationen finden Sie unter Firebase Authentication-Limits.

Die Methode verifyPhoneNumber ist wiedereintrittsfähig: Wenn Sie sie mehrmals aufrufen, z. B. in der Methode onAppear einer Ansicht, wird von der Methode verifyPhoneNumber keine zweite SMS gesendet, es sei denn, die ursprüngliche Anfrage hat das Zeitlimit überschritten.

Wenn Sie verifyPhoneNumber(_:uiDelegate:completion:) aufrufen, sendet Firebase eine Push-Benachrichtigung ohne Ton an Ihre App oder stellt dem Nutzer eine reCAPTCHA-Aufgabe. Nachdem Ihre App die Benachrichtigung erhalten hat oder der Nutzer die reCAPTCHA-Aufgabe abgeschlossen hat, sendet Firebase eine SMS 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 Nutzer anzumelden.

Die von Firebase gesendete SMS kann auch lokalisiert werden. Dazu geben Sie die Authentifizierungssprache über das Attribut languageCode in Ihrer Auth-Instanz an.
Swift
```
 // Change language code to french.
 Auth.auth().languageCode = "fr";
```
Objective-C
```
 // Change language code to french.
 [FIRAuth auth].languageCode = @"fr";
```
Speichern Sie die Bestätigungs-ID und stellen Sie sie wieder her, wenn Ihre App geladen wird. So ist gewährleistet, dass ihr auch dann eine gültige Bestätigungs-ID habt, wenn eure App beendet wird, bevor der Nutzer den Anmeldevorgang abgeschlossen hat (z. B. beim Wechsel zur SMS-App).

Sie können die Bestätigungs-ID beliebig speichern. Eine einfache Möglichkeit besteht darin, die Bestätigungs-ID mit dem NSUserDefaults-Objekt zu speichern:
Swift
```
UserDefaults.standard.set(verificationID, forKey: "authVerificationID")
```
Objective-C
```
NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
[defaults setObject:verificationID forKey:@"authVerificationID"];
```
Anschließend können Sie den gespeicherten Wert wiederherstellen:
Swift
```
let verificationID = UserDefaults.standard.string(forKey: "authVerificationID")
```
Objective-C
```
NSString *verificationID = [defaults stringForKey:@"authVerificationID"];
```

Wenn der Aufruf von verifyPhoneNumber(_:uiDelegate:completion:) erfolgreich ist, kannst du den Nutzer auffordern, den Bestätigungscode einzugeben, wenn er ihn per SMS erhält.

Nachdem der Nutzer deiner App den Bestätigungscode aus der SMS-Nachricht zur Verfügung gestellt hat, melde ihn an, indem du ein FIRPhoneAuthCredential-Objekt aus dem Bestätigungscode und der Bestätigungs-ID erstellst und dieses Objekt an signInWithCredential:completion: übergibst.

Lass dir den Bestätigungscode vom Nutzer geben.

Erstellen Sie ein FIRPhoneAuthCredential-Objekt aus dem Bestätigungscode und der Bestätigungs-ID.

Swift

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

Objective-C

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

Melden Sie den Nutzer mit dem FIRPhoneAuthCredential-Objekt an:

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

Mit fiktiven Telefonnummern testen

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

Testen Sie die Telefonnummer-Authentifizierung, ohne Ihr Nutzungskontingent zu verbrauchen.
Testen Sie die Telefonnummer-Authentifizierung, ohne eine tatsächliche SMS zu senden.
Sie können aufeinanderfolgende Tests mit derselben Telefonnummer ausführen, ohne dass die Geschwindigkeit gedrosselt wird. Dadurch wird das Risiko einer Ablehnung während der App Store-Überprüfung minimiert, falls der Prüfer dieselbe Telefonnummer zum Testen verwendet.
Sie können die App ohne zusätzlichen Aufwand in Entwicklungsumgebungen testen, z. B. in einem iOS-Simulator oder einem Android-Emulator ohne Google Play-Dienste.
Schreiben Sie Integrationstests, ohne durch Sicherheitsprüfungen blockiert zu werden, die normalerweise für echte Telefonnummern in einer Produktionsumgebung gelten.

Fiktive Telefonnummern müssen die folgenden Anforderungen erfüllen:

Verwenden Sie fiktive Telefonnummern, die noch nicht existieren. In Firebase Authentication können Sie keine vorhandenen Telefonnummern, die von echten Nutzern verwendet werden, als Testnummern festlegen. Eine Möglichkeit besteht darin, Nummern mit der Vorwahl 555 als US-amerikanische Testtelefonnummern zu verwenden, z. B. +1 650-555-3434.
Telefonnummern müssen im Hinblick auf die Länge und andere Einschränkungen korrekt formatiert sein. Sie werden genauso validiert wie die Telefonnummer eines echten Nutzers.
Sie können bis zu 10 Telefonnummern für die Entwicklung hinzufügen.
Verwende Testtelefonnummern und ‑codes, die schwer zu erraten sind, und ändere sie regelmäßig.

Fiktive Telefonnummern und Bestätigungscodes erstellen

Rufen Sie in der Firebase-Konsole Sicherheit > Authentifizierung auf.
Aktivieren Sie auf dem Tab Anmeldemethode den Anmeldeanbieter Telefon, falls noch nicht geschehen.
Maximieren Sie den Bereich Telefonnummern für Tests.
Geben Sie die Telefonnummer an, die Sie testen möchten, z. B. +1 650-555-3434.
Geben Sie den sechsstelligen Bestätigungscode für diese Nummer an, z. B. 654321.
Klicken Sie für jede Nummer auf Hinzufügen. Bei Bedarf können Sie die Telefonnummer und den zugehörigen Code löschen, indem Sie den Mauszeiger auf die entsprechende Zeile bewegen und auf das Papierkorbsymbol klicken.

Manuelle Tests

Sie können direkt eine fiktive Telefonnummer in Ihrer Anwendung verwenden. So können Sie während der Entwicklungsphasen manuelle Tests durchführen, ohne dass Kontingentprobleme oder Drosselungen auftreten. Sie können auch direkt über einen iOS-Simulator oder Android-Emulator testen, ohne dass die Google Play-Dienste installiert sind.

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-Nutzer mit dieser Telefonnummer erstellt. Der Nutzer hat dieselben Verhaltensweisen und Eigenschaften wie ein Nutzer mit einer echten Telefonnummer und kann auf dieselbe Weise auf Realtime Database/Cloud Firestore und andere Dienste zugreifen. Das während dieses Vorgangs erstellte ID-Token hat dieselbe Signatur wie ein echter Nutzer mit Telefonnummer.

Eine weitere Möglichkeit besteht darin, für diese Nutzer eine Testrolle über benutzerdefinierte Anforderungen festzulegen, um sie als Fake-Nutzer zu kennzeichnen, wenn Sie den Zugriff weiter einschränken möchten.

Integrationstests

Zusätzlich zu manuellen Tests bietet Firebase Authentication APIs, mit denen Sie Integrationstests für die Authentifizierung per Telefonnummer schreiben können. Diese APIs deaktivieren die App-Überprüfung, indem sie die reCAPTCHA-Anforderung im Web und die stillen Push-Benachrichtigungen in iOS deaktivieren. Dadurch werden Automatisierungstests in diesen Abläufen möglich und einfacher zu implementieren. Außerdem können damit Abläufe für die sofortige Bestätigung auf Android-Geräten getestet werden.

Unter iOS muss die Einstellung appVerificationDisabledForTesting auf TRUE gesetzt werden, bevor verifyPhoneNumber aufgerufen wird. Dies wird ohne APNs-Token oder das Senden von stillen Push-Benachrichtigungen im Hintergrund verarbeitet, was das Testen in einem Simulator erleichtert. Dadurch wird auch der reCAPTCHA-Fallback-Ablauf deaktiviert.

Wenn die App-Überprüfung deaktiviert ist, schlägt die Anmeldung mit einer echten Telefonnummer fehl. Mit dieser API können nur fiktive Telefonnummern verwendet werden.

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 verwendet Method Swizzling, um das APNs-Token Ihrer App automatisch abzurufen, die von Firebase an Ihre App gesendeten stillen Push-Benachrichtigungen zu verarbeiten und die Weiterleitung des benutzerdefinierten Schemas von der reCAPTCHA-Überprüfungsseite während der Überprüfung automatisch abzufangen.

Wenn Sie Swizzling nicht verwenden möchten, können Sie es deaktivieren, indem Sie das Flag FirebaseAppDelegateProxyEnabled in die Datei „Info.plist“ Ihrer App einfügen und auf NO setzen. Wenn Sie dieses Flag auf NO setzen, wird das Swizzling auch für andere Firebase-Produkte deaktiviert, einschließlich Firebase Cloud Messaging.

Wenn Sie Swizzling deaktivieren, müssen Sie das APNs-Gerätetoken, Push-Benachrichtigungen und die Weiterleitungs-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 Weiterleitungs-URL für das benutzerdefinierte Schema explizit an Firebase Authentication übergeben.

Implementieren Sie die Methode application(_:didRegisterForRemoteNotificationsWithDeviceToken:), um das APNs-Gerätetoken abzurufen, und übergeben Sie das Gerätetoken darin an die Methode setAPNSToken(_:type:) von Auth.

Hinweis: SwiftUI-Apps sollten die Property Wrapper UIApplicationDelegateAdaptor oder NSApplicationDelegateAdaptor verwenden, um einen Typ bereitzustellen, der dem entsprechenden App-Delegatprotokoll entspricht.

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

Wenn Sie Push-Benachrichtigungen verarbeiten möchten, prüfen Sie in der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:):, ob Benachrichtigungen im Zusammenhang mit der Firebase-Authentifizierung vorliegen. Rufen Sie dazu die Methode canHandleNotification(_:) von Auth auf.

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

Wenn Sie die Weiterleitungs-URL für das benutzerdefinierte Schema verarbeiten möchten, implementieren Sie die Methode application(_:open:options:) und übergeben Sie darin die URL an die Methode canHandleURL(_:) von 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.
}

Wenn Sie SwiftUI oder UISceneDelegate verwenden, implementieren Sie die Methode scene(_:openURLContexts:), um die Weiterleitungs-URL zu verarbeiten, und übergeben Sie die URL an die Methode canHandleURL(_:) von 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.
  }
}

Nächste Schritte

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und mit den Anmeldedaten verknüpft, mit denen sich der Nutzer angemeldet hat, also mit dem Nutzernamen und dem Passwort, der Telefonnummer oder den Informationen des Authentifizierungsanbieters. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Nutzer anmeldet.

In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers aus dem Objekt User abrufen. Weitere Informationen finden Sie unter Nutzer verwalten.
In Ihren Sicherheitsregeln für Firebase Realtime Database und Cloud Storage können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der Variablen auth abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

Sie können Nutzern erlauben, sich mit mehreren Authentifizierungsanbietern in Ihrer App anzumelden, indem Sie Anmeldedaten des Authentifizierungsanbieters mit einem vorhandenen Nutzerkonto verknüpfen.

Wenn Sie einen Nutzer abmelden möchten, rufen Sie signOut: auf.

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

Sie können auch Fehlerbehandlungscode für alle Authentifizierungsfehler hinzufügen. Weitere Informationen finden Sie unter Fehler verarbeiten.

Mit einer Telefonnummer bei Firebase auf Apple-Plattformen authentifizieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweis

Sicherheitsbedenken

Anmeldung per Telefonnummer für Ihr Firebase-Projekt aktivieren

App-Überprüfung aktivieren

Lautlose Benachrichtigungen erhalten

reCAPTCHA-Überprüfung einrichten

Bestätigungscode an das Smartphone des Nutzers senden

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Nutzer mit dem Bestätigungscode anmelden

Swift

Objective-C

Swift

Objective-C

Mit fiktiven Telefonnummern testen

Fiktive Telefonnummern und Bestätigungscodes erstellen

Manuelle Tests

Integrationstests

Swift

Objective-C

Anhang: Anmeldung per Smartphone ohne Swizzling verwenden

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Nächste Schritte

Swift

Objective-C

Mit einer Telefonnummer bei Firebase auf Apple-Plattformen authentifizieren