Diese Seite wurde von der Cloud Translation API übersetzt.

Authentifizieren Sie sich bei Firebase mit einer Telefonnummer und C++

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.

In diesem Dokument wird beschrieben, wie Sie mit dem Firebase SDK einen Anmeldeablauf für Telefonnummern implementieren.

Bevor Sie beginnen

Fügen Sie Ihrem C++-Projekt Firebase hinzu .
Wenn Sie Ihre App noch nicht mit Ihrem Firebase-Projekt verbunden haben, tun Sie dies über die Firebase-Konsole .
Machen Sie sich mit den Plattformanforderungen für die Anmeldung per Telefonnummer vertraut:
- Die Anmeldung per Telefonnummer gilt nur für mobile Plattformen.
- Unter iOS erfordert die Anmeldung per Telefonnummer ein physisches Gerät und funktioniert nicht auf einem Simulator.

Sicherheitsbedenken

Die Authentifizierung mit nur einer Telefonnummer ist zwar bequem, 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 die telefonnummernbasierte Anmeldung in Ihrer App verwenden, sollten Sie sie zusammen mit sichereren Anmeldemethoden anbieten und die Benutzer über die Sicherheitskompromisse bei der Verwendung der Telefonnummernanmeldung informieren.

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

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

Das Kontingent für Anmeldeanfragen für Telefonnummern von Firebase 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 .

Empfangen Sie APNs-Benachrichtigungen (Apple-Plattformen)

Um die Telefonnummernauthentifizierung auf Apple-Plattformen zu verwenden, muss Ihre App APNs-Benachrichtigungen von Firebase empfangen können. Wenn Sie einen Benutzer zum ersten Mal mit seiner Telefonnummer auf einem Gerät anmelden, sendet die Firebase-Authentifizierung eine stille Push-Benachrichtigung an das Gerät, um zu überprüfen, ob die Anmeldeanforderung für die Telefonnummer von Ihrer App stammt. (Aus diesem Grund kann die Anmeldung per Telefonnummer nicht auf einem Simulator verwendet werden.)

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

Aktivieren Sie in Xcode Push-Benachrichtigungen für Ihr Projekt.
Laden Sie Ihr APNs-Zertifikat in Firebase hoch. Wenn Sie noch kein APNs-Zertifikat haben, stellen Sie sicher, dass Sie eines im Apple Developer Member Center erstellen.
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. Wählen Sie die Schaltfläche Zertifikat hochladen für Ihr Entwicklungszertifikat, Ihr Produktionszertifikat oder beide aus. Mindestens einer ist erforderlich.
3. Wählen Sie für jedes Zertifikat die .p12-Datei aus und geben Sie ggf. das Kennwort ein. Stellen Sie sicher, dass die Paket-ID für dieses Zertifikat mit der Paket-ID Ihrer App übereinstimmt. Wählen Sie Speichern aus .

Senden Sie einen Bestätigungscode an das Telefon des Benutzers

Um die Anmeldung per Telefonnummer zu initiieren, zeigen Sie dem Benutzer eine Oberfläche, die ihn auffordert, seine Telefonnummer anzugeben, und rufen Sie dann PhoneAuthProvider::VerifyPhoneNumber auf, um anzufordern, dass Firebase einen Authentifizierungscode per SMS an das Telefon des Benutzers sendet:

Rufen Sie die Telefonnummer des Benutzers ab.
Die gesetzlichen Anforderungen sind unterschiedlich, aber als Best Practice und um die Erwartungen Ihrer Benutzer zu erfüllen, sollten Sie sie darüber informieren, dass sie bei Verwendung der telefonischen Anmeldung möglicherweise eine SMS-Nachricht zur Überprüfung erhalten und Standardgebühren anfallen.

Rufen Sie PhoneAuthProvider::VerifyPhoneNumber auf und übergeben Sie ihm die Telefonnummer des Benutzers.

class PhoneListener : public PhoneAuthProvider::Listener {
 public:
  ~PhoneListener() override {}

  void OnVerificationCompleted(PhoneAuthCredential credential) override {
    // Auto-sms-retrieval or instant validation has succeeded (Android only).
    // No need for the user to input the verification code manually.
    // `credential` can be used instead of calling GetCredential().
  }

  void OnVerificationFailed(const std::string& error) override {
    // Verification code not sent.
  }

  void OnCodeSent(const std::string& verification_id,
                  const PhoneAuthProvider::ForceResendingToken&
                      force_resending_token) override {
    // Verification code successfully sent via SMS.
    // Show the Screen to enter the Code.
    // Developer may want to save that verification_id along with other app states in case
    // the app is terminated before the user gets the SMS verification code.
  }
};

PhoneListener phone_listener;
PhoneAuhtOptions options;
options.timeout_milliseconds = kAutoVerifyTimeOut;
options.phone_number = phone_number;
PhoneAuthProvider& phone_provider = PhoneAuthProvider::GetInstance(auth);
phone_provider->VerifyPhoneNumber(options, &phone_listener);

Wenn Sie PhoneAuthProvider::VerifyPhoneNumber , Firebase anrufen,

(auf iOS) sendet eine stille Push-Benachrichtigung an Ihre App,
sendet eine SMS-Nachricht mit einem Authentifizierungscode an die angegebene Telefonnummer und übergibt eine Verifizierungs-ID an Ihre Vervollständigungsfunktion. Sie benötigen sowohl den Bestätigungscode als auch die Bestätigungs-ID, um den Benutzer anzumelden.
Hinweis: Abhängig von Ihrem Abrechnungsplan sind Sie möglicherweise auf ein tägliches Kontingent an gesendeten SMS-Nachrichten beschränkt. Siehe Firebase-Authentifizierungslimits .

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 abgeschlossen hat (z. B. beim Wechseln zur SMS-App).
Sie können die Verifizierungs-ID beliebig beibehalten. Wenn Sie mit einem plattformübergreifenden C++-Framework schreiben, sollte es Benachrichtigungen für die App-Beendigung und -Wiederherstellung bereitstellen. Bei diesen Ereignissen können Sie die Verifizierungs-ID speichern bzw. wiederherstellen.

Wenn der Aufruf von VerifyPhoneNumber dazu führt, dass OnCodeSent auf Ihrem Listener aufgerufen wird, können Sie den Benutzer auffordern, den Bestätigungscode einzugeben, wenn er ihn in der SMS-Nachricht erhält.

Wenn andererseits der Aufruf von VerifyPhoneNumber zu OnVerificationCompleted führt, war die automatische Verifizierung erfolgreich und Sie haben jetzt ein PhoneAuthCredential , das Sie wie unten beschrieben verwenden können.

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

Holen Sie sich den Bestätigungscode vom Benutzer.

Erstellen Sie ein Credential Objekt aus dem Verifizierungscode und der Verifizierungs-ID.

PhoneAuthCredential credential = phone_auth_provider->GetCredential(
    verification_id_.c_str(), verification_code.c_str());

Melden Sie den Benutzer mit dem Credential an:

Future<User> future = auth_->SignInWithCredential(credential);
future.OnCompletion(
    [](const Future<User*>& result, void*) {
      if (result.error() == kAuthErrorNone) {
        // Successful.
        // User is signed in.
        User user = *result.result();

        // This should display the phone number.
        printf("Phone number: %s", user.phone_number().c_str());

        // The phone number provider UID is the phone number itself.
        printf("Phone provider uid: %s", user.uid().c_str());

        // The phone number providerID is 'phone'
        printf("Phone provider ID: %s", user.provider_id().c_str());
      } else {
        // Error.
        printf("Sign in error: %s", result.error_message().c_str());
      }
    },
    nullptr);

Nächste Schritte

Nachdem sich ein Benutzer zum ersten Mal angemeldet hat, wird ein neues Benutzerkonto erstellt und mit den Anmeldeinformationen verknüpft – d. h. dem Benutzernamen und Kennwort, der Telefonnummer oder den Authentifizierungsanbieterinformationen –, mit denen sich der Benutzer angemeldet hat. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Benutzer in jeder App in Ihrem Projekt zu identifizieren, unabhängig davon, wie sich der Benutzer anmeldet.

In Ihren Apps können Sie die grundlegenden Profilinformationen des Benutzers aus dem Objekt firebase::auth::User abrufen:

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string name = user.display_name();
  std::string email = user.email();
  std::string photo_url = user.photo_url();
  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

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

Sie können Benutzern erlauben, 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:

auth->SignOut();