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. Dieses Tool enthält ein Anmelde-Widget, mit dem Anmeldeabläufe für die Anmeldung per Telefonnummer sowie die passwortbasierte und föderierte Anmeldung implementiert werden. In diesem Dokument wird beschrieben, wie Sie mit dem Firebase SDK einen Anmeldevorgang per Telefonnummer implementieren.

Telefonnummern, die Endnutzer zur Authentifizierung angeben, werden von Google gesendet und gespeichert, um Spam und Missbrauch in allen Google-Diensten zu verhindern, einschließlich Firebase. Entwickler müssen die Einwilligung der Endnutzer einholen, bevor sie den Anmeldedienst für Telefonnummern von Firebase Authentication verwenden.

Hinweis

1. Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verknüpft haben, tun Sie dies in der Firebase Console.

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

   In unserem Installationsleitfaden erfahren Sie, wie Sie Ihrem Apple-Projekt Firebase SDKs auf verschiedene Arten hinzufügen können, z. B. durch direkten Import von Frameworks und Verwendung von CocoaPods.
   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:

     https://github.com/firebase/firebase-ios-sdk.git

   Hinweis: Neue Projekte sollten die Standardversion (neueste) des SDK verwenden. Bei Bedarf können Sie jedoch eine ältere Version auswählen.
   3. Wählen Sie die Bibliothek Firebase Authentication aus.
   4. Fügen Sie das Flag -ObjC dem Abschnitt Other Linker Flags (Weitere Verknüpfungsmerker) in den Build-Einstellungen des Ziels hinzu.
   5. Wenn Sie fertig, beginnt Xcode automatisch, Ihre Abhängigkeiten im Hintergrund aufzulösen und herunterzuladen.

Sicherheitsbedenken

Die Authentifizierung mit nur einer Telefonnummer ist zwar praktisch, aber weniger sicher als die anderen verfügbaren Methoden, da eine 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 standortbasierte Anmeldung per Telefonnummer anbieten, sollten Sie sie zusammen mit sichereren Anmeldemethoden anbieten und die Nutzer über die Sicherheitsrisiken der Anmeldung per Telefonnummer informieren.

Anmeldung per Telefonnummer für Ihr Firebase-Projekt aktivieren

Damit Nutzer per SMS angemeldet werden können, müssen Sie zuerst die Anmeldemethode „Telefonnummer“ für Ihr Firebase-Projekt aktivieren:

1. Öffnen Sie in der Firebase Console den Bereich Authentifizierung.
2. Aktivieren Sie auf der Seite Anmeldemethode die Anmeldemethode Telefonnummer.

App-Überprüfung aktivieren

Damit die Telefonnummernauthentifizierung verwendet werden kann, muss Firebase prüfen können, ob Anfragen zur Anmeldung per Telefonnummer von Ihrer App stammen. Firebase Authentication bietet dazu zwei Möglichkeiten:

• Lautlose APNs-Benachrichtigungen: Wenn Sie einen Nutzer zum ersten Mal mit seiner Telefonnummer auf einem Gerät anmelden, sendet Firebase Authentication ein Token über eine lautlose 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 stumme Benachrichtigungen keine ausdrückliche Nutzereinwilligung erforderlich. Daher ist es unerheblich, ob ein Nutzer die APNs-Benachrichtigungen in der App abgelehnt hat. Die App muss also nicht die Nutzereinwilligung zum Empfang von Push-Benachrichtigungen anfordern, wenn die Firebase-Authentifizierung per Telefonnummer 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 Sie Ihre App in einem iOS-Simulator testen, verwendet Firebase Authentication die reCAPTCHA-Überprüfung, um die Anmeldung auf dem Smartphone abzuschließen. Die reCAPTCHA-Herausforderung kann oft abgeschlossen werden, ohne dass der Nutzer etwas lösen muss.
Die Telefonauthentifizierung unter iOS verwendet für die Bestätigung der Client-App lautlose Push-Benachrichtigungen. Wenn das fehlschlägt, wird auf reCAPTCHA zurückgegriffen. Für diesen reCAPTCHA-Vorgang muss Ihr API-Schlüssel uneingeschränkt oder für „${PROJECT_NAME}.firebaseapp.com“ auf die Zulassungsliste gesetzt sein.

Wenn stumme Push-Benachrichtigungen richtig konfiguriert sind, wird der reCAPTCHA-Vorgang nur für einen sehr kleinen Prozentsatz der Nutzer ausgeführt. Sie sollten jedoch dafür sorgen, dass die Anmeldung per Telefonnummer ordnungsgemäß funktioniert, unabhängig davon, ob stille Push-Benachrichtigungen verfügbar sind oder nicht.

Testen Sie Ihre App auf einem physischen Gerät, um sicherzustellen, dass beide Szenarien ordnungsgemäß funktionieren. Dabei sollte die Hintergrundaktualisierung sowohl aktiviert als auch deaktiviert sein. Wenn die Hintergrundaktualisierung von Apps deaktiviert ist, sollten Sie sich nach Abschluss der reCAPTCHA-Aufgabe anmelden können. Sie können den reCAPTCHA-Vorgang auch testen, indem Sie Ihre App in einem iOS-Simulator ausführen, in dem immer der reCAPTCHA-Vorgang verwendet wird.

Stumme Benachrichtigungen erhalten

So aktivieren Sie APN-Benachrichtigungen zur Verwendung mit Firebase Authentication:

1. Aktivieren Sie Push-Benachrichtigungen für Ihr Projekt in Xcode.

2. Laden Sie Ihren APNs-Authentifizierungsschlüssel in Firebase hoch. Wenn Sie noch keinen APN-Authentifizierungsschlüssel haben, erstellen Sie einen im Apple Developer Member Center.

   1. Klicken Sie in der Firebase Console in Ihrem Projekt auf das Zahnradsymbol, dann auf Projekteinstellungen und dann auf den Tab Cloud Messaging.

   2. Klicken Sie unter APNs-Authentifizierungsschlüssel im Abschnitt Konfiguration der iOS-App auf die Schaltfläche Hochladen.

   3. Rufen Sie den Speicherort auf, an dem Sie den 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 das Zertifikat hochladen.

3. Aktivieren Sie in Xcode die Funktion „Hintergrundmodi“ für Ihr Projekt und klicken Sie dann auf die Kästchen für die Modi Abruf im Hintergrund und Remote-Benachrichtigungen.

reCAPTCHA-Überprüfung einrichten

So aktivieren Sie die reCAPTCHA-Verifizierung für das Firebase SDK:

1. Fügen Sie Ihrem Xcode-Projekt benutzerdefinierte URL-Schemas hinzu:
   1. Öffnen Sie die Projektkonfiguration: Doppelklicken Sie in der linken Baumansicht auf den Projektnamen. Wählen Sie im Bereich ZIELE Ihre App aus, gehen Sie dann zum Tab Info und maximieren Sie den Bereich URL-Typen.
   2. Klicken Sie auf die Schaltfläche + und fügen Sie die codierte App-ID als URL-Schema hinzu. Sie finden die codierte App-ID auf der Seite Allgemeine Einstellungen der Firebase Console im Abschnitt für Ihre iOS-App. Lassen Sie die anderen Felder leer.

      Die Konfiguration sollte dann in etwa so aussehen (aber mit Ihren anwendungsspezifischen Werten):

      
2. Optional: Wenn Sie anpassen möchten, wie Ihre App SFSafariViewController darstellt, wenn das reCAPTCHA dem Nutzer angezeigt wird, 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 Mobiltelefon des Nutzers.

Wenn Sie die Anmeldung per Telefonnummer starten möchten, zeigen Sie dem Nutzer eine Benutzeroberfläche an, in der er aufgefordert wird, seine Telefonnummer anzugeben. Rufen Sie dann verifyPhoneNumber(_:uiDelegate:completion:) auf, um Firebase zu bitten, dem Nutzer per SMS einen Authentifizierungscode zu senden:

1. Telefonnummer des Nutzers abrufen

   Die rechtlichen Anforderungen variieren. Als Best Practice und um die Erwartungen Ihrer Nutzer zu steuern, sollten Sie sie darüber informieren, dass sie bei der Anmeldung per Smartphone möglicherweise eine SMS zur Bestätigung erhalten und dass dabei die üblichen Gebühren anfallen.

2. Rufen Sie verifyPhoneNumber(_:uiDelegate:completion:) auf und übergeben Sie die Telefonnummer des Nutzers.
   SwiftObjective-C
   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
         // ...
     }

   [[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 Abrechnungsmodell ist die Anzahl der täglich gesendeten SMS möglicherweise begrenzt. Weitere Informationen finden Sie unter Firebase Authentication Limits.

   Die Methode verifyPhoneNumber ist reentrant: Wenn Sie sie mehrmals aufrufen, z. B. in der onAppear-Methode einer Ansicht, sendet die Methode verifyPhoneNumber nur dann eine zweite SMS, wenn die ursprüngliche Anfrage abgelaufen ist.

   Wenn Sie verifyPhoneNumber(_:uiDelegate:completion:) aufrufen, sendet Firebase eine stumme Push-Benachrichtigung an Ihre App oder stellt dem Nutzer eine reCAPTCHA-Aufgabe. Nachdem Ihre App die Benachrichtigung erhalten hat oder der Nutzer die reCAPTCHA-Herausforderung abgeschlossen hat, sendet Firebase eine SMS mit einem Authentifizierungscode an die angegebene Telefonnummer und übergibt Ihrer Funktion zum Abschließen eine Bestätigungs-ID. 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, indem Sie die Authentifizierungssprache über das Attribut languageCode in Ihrer Auth-Instanz angeben.

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

    // Change language code to french.
    [FIRAuth auth].languageCode = @"fr";

3. Speichern Sie die Bestätigungs-ID und stellen Sie sie wieder her, wenn Ihre App geladen wird. So können Sie dafür sorgen, dass Sie immer noch eine gültige Bestätigungs-ID haben, wenn Ihre 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:

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

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

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

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

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

Wenn der Aufruf von verifyPhoneNumber(_:uiDelegate:completion:) erfolgreich war, kannst du den Nutzer auffordern, den Bestätigungscode einzugeben, sobald er ihn in der SMS-Nachricht erhält.

Um Missbrauch zu verhindern, wird in Firebase die Anzahl der SMS-Nachrichten begrenzt, die innerhalb eines bestimmten Zeitraums an eine einzelne Telefonnummer gesendet werden können. Wenn Sie dieses Limit überschreiten, werden Anfragen zur Bestätigung der Telefonnummer möglicherweise gedrosselt. Wenn dieses Problem während der Entwicklung auftritt, verwenden Sie für den Test eine andere Telefonnummer oder versuchen Sie es später noch einmal.

Nutzer mit dem Bestätigungscode anmelden

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

1. Bitten Sie den Nutzer, Ihnen den Bestätigungscode zu nennen.
2. Erstelle ein FIRPhoneAuthCredential-Objekt aus dem Bestätigungscode und der Bestätigungs-ID.
   SwiftObjective-C
   let credential = PhoneAuthProvider.provider().credential(
     withVerificationID: verificationID,
     verificationCode: verificationCode
   )

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

3. Melden Sie den Nutzer mit dem FIRPhoneAuthCredential-Objekt an:
   SwiftObjective-C
   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
       // ...
   }

   [[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

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

• Die Authentifizierung per Telefonnummer testen, ohne das Nutzungskontingent zu verbrauchen
• Testen Sie die Authentifizierung per Telefonnummer, ohne eine SMS zu senden.
• Sie können aufeinanderfolgende Tests mit derselben Telefonnummer ausführen, ohne dass es zu Drosselung kommt. So wird das Risiko minimiert, dass die App bei der Überprüfung im App Store abgelehnt wird, wenn der Prüfer dieselbe Telefonnummer für die Tests verwendet.
• Sie können Ihre Apps ohne zusätzlichen Aufwand in Entwicklungsumgebungen testen, z. B. in einem iOS-Simulator oder einem Android-Emulator ohne Google Play-Dienste.
• Sie können Integrationstests schreiben, ohne von Sicherheitsprüfungen blockiert zu werden, die normalerweise auf echte Telefonnummern in einer Produktionsumgebung angewendet werden.

Fiktive Telefonnummern müssen folgende Anforderungen erfüllen:

1. Verwenden Sie Telefonnummern, die tatsächlich fiktiv sind und noch nicht vergeben wurden. Mit Firebase Authentication können Sie keine Telefonnummern festlegen, die von echten Nutzern verwendet werden. Eine Möglichkeit besteht darin, als US-Testtelefonnummern Nummern mit dem Präfix „555“ zu verwenden, z. B.: [phone]
2. Telefonnummern müssen hinsichtlich Länge und anderer Einschränkungen richtig formatiert sein. Sie werden jedoch genauso wie die Telefonnummer eines echten Nutzers überprüft.
3. Sie können bis zu zehn Telefonnummern für die Entwicklungszwecke 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 Console den Bereich Authentifizierung.
2. Aktivieren Sie auf dem Tab Anmeldemethode den Telefonanbieter, falls noch nicht geschehen.
3. Öffnen Sie das Akkordeonmenü Telefonnummern für Tests.
4. Geben Sie die Telefonnummer an, die Sie testen möchten, z. B. [phone].
5. Geben Sie den sechsstelligen Bestätigungscode für diese Nummer ein, z. B. 654321.
6. Fügen Sie die Nummer hinzu. Falls erforderlich, können Sie die Telefonnummer und den Code löschen. Bewegen Sie dazu den Mauszeiger auf die entsprechende Zeile und klicken Sie auf das Papierkorbsymbol.

Manuelle Tests

Sie können sofort mit der Verwendung einer fiktiven Telefonnummer in Ihrer Anwendung beginnen. So können Sie während der Entwicklungsphase manuelle Tests durchführen, ohne auf Kontingentprobleme oder Drosselung zu stoßen. Sie können auch direkt über einen iOS-Simulator oder Android-Emulator testen, ohne dass Google Play-Dienste installiert sind.

Wenn Sie die fiktive Telefonnummer angeben und den Bestätigungscode senden, wird keine 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 dasselbe Verhalten und dieselben Eigenschaften wie ein echter Nutzer mit Telefonnummer und kann auf dieselbe Weise auf Realtime Database/Cloud Firestore und andere Dienste zugreifen. Das bei diesem Vorgang erstellte ID-Token hat dieselbe Signatur wie ein Nutzer mit einer echten Telefonnummer.

Da das ID-Token für die fiktive Telefonnummer dieselbe Signatur wie die einer echten Telefonnummer hat, ist es wichtig, diese Nummern sicher zu speichern und kontinuierlich zu recyceln.

Eine weitere Möglichkeit besteht darin, diesen Nutzern über benutzerdefinierte Ansprüche eine Testrolle zuzuweisen, 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, die Sie bei der Entwicklung von Integrationstests für die Telefonauthentifizierung unterstützen. Mit diesen APIs wird die App-Überprüfung deaktiviert, indem die reCAPTCHA-Anforderung im Web und die Funktion für laute Push-Benachrichtigungen unter iOS deaktiviert wird. Dadurch sind automatisierte Tests in diesen Abläufen möglich und einfacher zu implementieren. Außerdem können Sie damit Instant-Bestätigungsabläufe auf Android-Geräten testen.

Achten Sie darauf, dass die App-Bestätigung für Produktions-Apps nicht deaktiviert ist und dass in Ihrer Produktions-App keine fiktiven Telefonnummern hartcodiert sind.

Unter iOS muss die appVerificationDisabledForTesting-Einstellung auf TRUE gesetzt sein, bevor verifyPhoneNumber aufgerufen wird. Die Verarbeitung erfolgt ohne APNs-Token und ohne Senden stummgeschalteter Push-Benachrichtigungen im Hintergrund. Das erleichtert das Testen in einem Simulator. Dadurch wird auch der reCAPTCHA-Fallback-Vorgang deaktiviert.

Wenn die App-Bestätigung deaktiviert ist, kann die Anmeldung nicht mit einer fiktiven Telefonnummer abgeschlossen werden. Mit dieser API können nur fiktive Telefonnummern verwendet werden.

SwiftObjective-C

let phoneNumber = "[phone]"

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

NSString *phoneNumber = @"[phone]";

// 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: Anmeldung über das Smartphone ohne Zufallsmix verwenden

Firebase Authentication verwendet das Methode-Swizzling, um das APNs-Token Ihrer App automatisch abzurufen, die stillen Push-Benachrichtigungen zu verarbeiten, die Firebase an Ihre App sendet, und die Weiterleitung über das benutzerdefinierte Schema von der reCAPTCHA-Bestätigungsseite während der Bestätigung automatisch abzufangen.

Wenn Sie das Swapping nicht verwenden möchten, können Sie es deaktivieren, indem Sie der Info.plist-Datei Ihrer App das Flag FirebaseAppDelegateProxyEnabled hinzufügen und es auf NO festlegen. Wenn Sie dieses Flag auf NO festlegen, wird das Swapping auch für andere Firebase-Produkte deaktiviert, einschließlich Firebase Cloud Messaging.

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

Wenn Sie eine SwiftUI-Anwendung entwickeln, sollten Sie auch das APNs-Gerätetoken, Push-Benachrichtigungen und die URL für die Weiterleitung zum benutzerdefinierten Schema an Firebase Authentication übergeben.

Um das APNs-Gerätetoken abzurufen, implementiere die Methode application(_:didRegisterForRemoteNotificationsWithDeviceToken:) und übergebe darin das Gerätetoken an die Methode setAPNSToken(_:type:) von Auth.

Hinweis: In SwiftUI-Apps sollten die Property Wrapper UIApplicationDelegateAdaptor oder NSApplicationDelegateAdaptor verwendet werden, um einen Typ anzugeben, der dem entsprechenden App-Delegate-Protokoll entspricht.

SwiftObjective-C

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

- (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 du Push-Benachrichtigungen verarbeiten möchtest, musst du in der Methode application(_:didReceiveRemoteNotification:fetchCompletionHandler:): nach Benachrichtigungen zur Firebase-Authentifizierung suchen. Rufe dazu die Methode canHandleNotification(_:) von Auth auf.

SwiftObjective-C

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

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

Implementieren Sie zum Verarbeiten der Weiterleitungs-URL des benutzerdefinierten Schemas die Methode application(_:open:options:) und übergeben Sie darin die URL an die Methode canHandleURL(_:) von Auth.

SwiftObjective-C

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

- (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 in dieser Methode an die canHandleURL(_:)-Methode von Auth.

SwiftObjective-C

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

- (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, d. h. mit dem Nutzernamen und Passwort, der Telefonnummer oder den Informationen zum Authentifizierungsanbieter, mit denen sich der Nutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in allen Apps in Ihrem Projekt zu identifizieren, unabhängig davon, wie er sich anmeldet.

• In Ihren Apps können Sie die grundlegenden Profilinformationen des Nutzers über das User-Objekt abrufen. Weitere Informationen finden Sie unter Nutzer verwalten.

• In Ihren Firebase Realtime Database- und Cloud Storage-Sicherheitsregeln 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 über mehrere Authentifizierungsanbieter in Ihrer App anzumelden, indem Sie die Anmeldedaten des Authentifizierungsanbieters mit einem vorhandenen Nutzerkonto verknüpfen.

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

SwiftObjective-C

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

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

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