Diese Seite wurde von der Cloud Translation API übersetzt.

Mit Twitter auf Apple-Plattformen authentifizieren

Sie können Ihren Nutzern die Authentifizierung bei Firebase mithilfe von OAuth-Anbietern wie Twitter, indem Sie generisches OAuth-Login in Ihre App integrieren. Verwenden Sie dazu das Firebase SDK, den gesamten Anmeldevorgang ausführen.

Hinweis

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

Gehen Sie in Xcode bei geöffnetem App-Projekt zu File > Pakete hinzufügen.
Fügen Sie bei entsprechender Aufforderung das Firebase Apple Platforms SDK-Repository hinzu:

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

Wählen Sie die Firebase Authentication-Bibliothek aus.
Fügen Sie in den Build-Einstellungen des Ziels im Bereich Other Linker Flags das Flag -ObjC hinzu.
Wenn Sie fertig, beginnt Xcode automatisch, Ihre Abhängigkeiten im Hintergrund aufzulösen und herunterzuladen.

Um Nutzer mit Twitter-Konten anzumelden, müssen Sie zunächst Twitter für die Anmeldung aktivieren. für Ihr Firebase-Projekt erstellen:

Fügen Sie Ihrem Apple-Projekt Firebase hinzu.
Fügen Sie die folgenden Pods in Ihr Podfile ein:
```
pod 'FirebaseAuth'
```
Öffnen Sie in der Firebase Console den Bereich Auth.
Aktivieren Sie auf dem Tab Anmeldemethode den Twitter-Anbieter.
Fügen Sie der Anbieterkonfiguration den API-Schlüssel und das API-Secret aus der Entwicklerkonsole des Anbieters hinzu:
1. App registrieren als Entwickleranwendung auf Twitter und rufen Sie den OAuth-API-Schlüssel Ihrer App ab. und API-Secret.
2. Prüfen Sie, ob der OAuth-Weiterleitungs-URI von Firebase (z.B. my-app-12345.firebaseapp.com/__/auth/handler) die als Callback-URL für die Autorisierung festgelegt ist. Wählen Sie dazu in den App-Einstellungen auf Ihrem Konfiguration der Twitter-App
Klicken Sie auf Speichern.

Anmeldevorgang mit dem Firebase SDK durchführen

Gehen Sie so vor, um den Anmeldevorgang mit dem Firebase Apple Platforms SDK durchzuführen:

Fügen Sie Ihrem Xcode-Projekt benutzerdefinierte URL-Schemas hinzu:
1. Öffnen Sie die Projektkonfiguration: Doppelklicken Sie auf den Projektnamen in der Baumansicht links. Wählen Sie unter ZIELE Ihre App aus und Wählen Sie den Tab Info aus und maximieren Sie den Bereich URL-Typen.
2. Klicken Sie auf die Schaltfläche + und fügen Sie die codierte App-ID als URL hinzu. . Ihre codierte App-ID finden Sie auf der Allgemein Einstellungen der Firebase Console im Bereich für Ihr iOS-Gerät Lassen Sie die anderen Felder leer.
  Die Konfiguration sollte dann in etwa so aussehen (aber mit Ihren anwendungsspezifischen Werten):

Instanz eines OAuthProviders mithilfe der Anbieter-ID erstellen twitter.com

Swift

    var provider = OAuthProvider(providerID: "twitter.com")

Objective-C

    FIROAuthProvider *provider = [FIROAuthProvider providerWithProviderID:@"twitter.com"];

Optional: Geben Sie zusätzliche benutzerdefinierte OAuth-Parameter an, die mit der OAuth-Anfrage gesendet werden sollen.
Swift
```
    provider.customParameters = [
      "lang": "fr"
      ]
    
```
Objective-C
```
    [provider setCustomParameters:@{@"lang": @"fr"}];
    
```
Informationen zu den von Twitter unterstützten Parametern finden Sie in der OAuth-Dokumentation für Twitter Hinweis: Sie können keine für Firebase erforderlichen Parameter mit setCustomParameters übergeben. Diese Parameter sind client_id, redirect_uri, response_type, scope und state.
Optional: Wenn Sie anpassen möchten, wie Ihre App die Daten SFSafariViewController oder UIWebView, wenn dem Nutzer das reCAPTCHA angezeigt wird, erstellen Sie eine benutzerdefinierte Klasse, die den an das Protokoll AuthUIDelegate und übergeben es an credentialWithUIDelegate

Authentifizieren Sie sich bei Firebase mithilfe des OAuth-Anbieterobjekts.

Swift

    provider.getCredentialWith(nil) { credential, error in
      if error != nil {
        // Handle error.
      }
      if credential != nil {
        Auth.auth().signIn(with: credential) { authResult, error in
          if error != nil {
            // Handle error.
          }
          // User is signed in.
          // IdP data available in authResult.additionalUserInfo.profile.
          // Twitter OAuth access token can also be retrieved by:
          // (authResult.credential as? OAuthCredential)?.accessToken
          // Twitter OAuth ID token can be retrieved by calling:
          // (authResult.credential as? OAuthCredential)?.idToken
          // Twitter OAuth secret can be retrieved by calling:
          // (authResult.credential as? OAuthCredential)?.secret
        }
      }
    }

Objective-C

    [provider getCredentialWithUIDelegate:nil
                               completion:^(FIRAuthCredential *_Nullable credential, NSError *_Nullable error) {
      if (error) {
       // Handle error.
      }
      if (credential) {
        [[FIRAuth auth] signInWithCredential:credential
                                  completion:^(FIRAuthDataResult *_Nullable authResult, NSError *_Nullable error) {
          if (error) {
            // Handle error.
          }
          // User is signed in.
          // IdP data available in authResult.additionalUserInfo.profile.
          // Twitter OAuth access token can also be retrieved by:
          // authResult.credential.accessToken
          // Twitter OAuth ID token can be retrieved by calling:
          // authResult.credential.idToken
          // Twitter OAuth secret can be retrieved by calling:
          // authResult.credential.secret
        }];
      }
    }];

Mit dem OAuth-Zugriffstoken können Sie die Twitter API aufrufen.

Um beispielsweise grundlegende Profilinformationen abzurufen, können Sie die REST API aufrufen, und übergeben das Zugriffstoken im Header Authorization:

https://api.twitter.com/labs/1/users?usernames=TwitterDev

Die obigen Beispiele konzentrieren sich zwar auf Anmeldeabläufe, Sie haben aber auch die Möglichkeit, Möglichkeit, einen Twitter-Anbieter mit einem vorhandenen Nutzer zu verknüpfen Sie können beispielsweise mehrere Anbieter mit demselben Nutzer verknüpfen, damit er sich mit jedem anmelden kann.

Swift

    Auth().currentUser.link(withCredential: credential) { authResult, error in
      if error != nil {
        // Handle error.
      }
      // Twitter credential is linked to the current user.
      // IdP data available in authResult.additionalUserInfo.profile.
      // Twitter OAuth access token can also be retrieved by:
      // (authResult.credential as? OAuthCredential)?.accessToken
      // Twitter OAuth ID token can be retrieved by calling:
      // (authResult.credential as? OAuthCredential)?.idToken
      // Twitter OAuth secret can be retrieved by calling:
      // (authResult.credential as? OAuthCredential)?.secret
    }

Objective-C

    [[FIRAuth auth].currentUser
        linkWithCredential:credential
                completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
      if (error) {
        // Handle error.
      }
      // Twitter credential is linked to the current user.
      // IdP data available in authResult.additionalUserInfo.profile.
      // Twitter OAuth access token is can also be retrieved by:
      // ((FIROAuthCredential *)authResult.credential).accessToken
      // Twitter OAuth ID token can be retrieved by calling:
      // ((FIROAuthCredential *)authResult.credential).idToken
      // Twitter OAuth secret can be retrieved by calling:
      // ((FIROAuthCredential *)authResult.credential).secret
    }];

Dasselbe Muster kann mit reauthenticateWithCredential verwendet werden, können zum Abrufen neuer Anmeldedaten für vertrauliche Vorgänge verwendet werden, die Letzte Anmeldung

Swift

    Auth().currentUser.reauthenticateWithCredential(withCredential: credential) { authResult, error in
      if error != nil {
        // Handle error.
      }
      // User is re-authenticated with fresh tokens minted and
      // should be able to perform sensitive operations like account
      // deletion and email or password update.
      // IdP data available in result.additionalUserInfo.profile.
      // Additional OAuth access token is can also be retrieved by:
      // (authResult.credential as? OAuthCredential)?.accessToken
      // Twitter OAuth ID token can be retrieved by calling:
      // (authResult.credential as? OAuthCredential)?.idToken
      // Twitter OAuth secret can be retrieved by calling:
      // (authResult.credential as? OAuthCredential)?.secret
    }

Objective-C

    [[FIRAuth auth].currentUser
        reauthenticateWithCredential:credential
                          completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
      if (error) {
        // Handle error.
      }
      // User is re-authenticated with fresh tokens minted and
      // should be able to perform sensitive operations like account
      // deletion and email or password update.
      // IdP data available in result.additionalUserInfo.profile.
      // Additional OAuth access token is can also be retrieved by:
      // ((FIROAuthCredential *)authResult.credential).accessToken
      // Twitter OAuth ID token can be retrieved by calling:
      // ((FIROAuthCredential *)authResult.credential).idToken
      // Twitter OAuth secret can be retrieved by calling:
      // ((FIROAuthCredential *)authResult.credential).secret
    }];

Fehler beim Vorhandensein eines Kontos mit unterschiedlichen Anmeldedaten beheben

Wenn Sie in der Firebase-Konsole die Einstellung Ein Konto pro E-Mail-Adresse aktiviert haben, Ein Nutzer versucht, sich mit einer E-Mail-Adresse bei einem Anbieter wie Twitter anzumelden, für den Anbieter eines anderen Firebase-Nutzers (z. B. Google) existiert, wird der Fehler FIRAuthErrorCodeAccountExistsWithDifferentCredential wird zusammen mit einer temporären FIRAuthCredential-Objekt (Twitter-Anmeldedaten). Schließen Sie die Anmeldung im muss sich der Nutzer zuerst beim vorhandenen Anbieter (Google) anmelden und dann auf den Frühere FIRAuthCredential (Twitter-Anmeldedaten). Das sieht dann so aus:

Swift

  // Sign-in with an OAuth credential.
  provider.getCredentialWith(nil) { credential, error in
    // An account with the same email already exists.
    if (error as NSError?)?.code == AuthErrorCode.accountExistsWithDifferentCredential.rawValue {
      // Get pending credential and email of existing account.
      let existingAcctEmail = (error! as NSError).userInfo[AuthErrorUserInfoEmailKey] as! String
      let pendingCred = (error! as NSError).userInfo[AuthErrorUserInfoUpdatedCredentialKey] as! AuthCredential
      // Lookup existing account identifier by the email.
      Auth.auth().fetchProviders(forEmail:existingAcctEmail) { providers, error in
        // Existing email/password account.
        if (providers?.contains(EmailAuthProviderID))! {
          // Existing password account for email. Ask user to provide the password of the
          // existing account.
          // Sign in with existing account.
          Auth.auth().signIn(withEmail:existingAcctEmail, password:password) { user, error in
            // Successfully signed in.
            if user != nil {
              // Link pending credential to account.
              Auth.auth().currentUser?.linkAndRetrieveData(with: pendingCred) { result, error in
                // ...
              }
            }
          }
        }
      }
      return
    }

    // Other errors.
    if error != nil {
      // handle the error.
      return
    }

    // Sign in with the credential.
    if credential != nil {
      Auth.auth().signInAndRetrieveData(with: credential!) { result, error in
        if error != nil {
          // handle the error.
          return
        }
      }
    }
  }

Objective-C

  // Sign-in with an OAuth credential.
  [provider getCredentialWithUIDelegate:nil
                             completion:^(FIRAuthCredential *_Nullable credential, NSError *_Nullable error) {
    // An account with the same email already exists.
    if (error.code == FIRAuthErrorCodeAccountExistsWithDifferentCredential) {
      // Get pending credential and email of existing account.
      NSString *existingAcctEmail = error.userInfo[FIRAuthErrorUserInfoEmailKey];
      FIRAuthCredential *pendingCred = error.userInfo[FIRAuthErrorUserInfoUpdatedCredentialKey];
      // Lookup existing account identifier by the email.
      [[FIRAuth auth] fetchProvidersForEmail:existingAcctEmail
                                 completion:^(NSArray<NSString *> *_Nullable providers,
                                              NSError *_Nullable error) {
        // Existing email/password account.
        if ( [providers containsObject:FIREmailAuthProviderID] ) {
          // Existing password account for email. Ask user to provide the password of the
          // existing account.

          // Sign in with existing account.
          [[FIRAuth auth] signInWithEmail:existingAcctEmail
                                 password:password
                               completion:^(FIRUser *user, NSError *error) {
            // Successfully signed in.
            if (user) {
              // Link pending credential to account.
              [[FIRAuth auth].currentUser linkWithCredential:pendingCred
                                                  completion:^(FIRUser *_Nullable user,
                                                               NSError *_Nullable error) {
                // ...
              }];
            }
          }];
        }
      }];
      return;
    }

    // Other errors.
    if (error) {
      // handle the error.
      return;
    }

    // Sign in with the credential.
    if (credential) {
      [[FIRAuth auth] signInAndRetrieveDataWithCredential:credential
          completion:^(FIRAuthDataResult *_Nullable authResult,
                       NSError *_Nullable error) {
        if (error) {
          // handle the error.
          return;
        }
      }];
    }
  }];

Nächste Schritte

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und die mit den Anmeldedaten verknüpft sind, d. h. Nutzername und Passwort, oder Authentifizierungsanbieter-Informationen – also für den Nutzer, mit dem sich der Nutzer angemeldet hat. Diese neue -Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um in jeder App in Ihrem Projekt einen Nutzer erreichen, unabhängig davon, wie er sich anmeldet.

Die grundlegenden Profilinformationen der Nutzer finden Sie in Ihren Apps über die User -Objekt enthält. 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 mit Mehrfachauthentifizierung in Ihrer App anzumelden indem Sie die Anmeldedaten des Authentifizierungsanbieters mit einem eines bestehenden Nutzerkontos.

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 Code zur Fehlerbehandlung für den gesamten Authentifizierungsbereich hinzufügen. Fehler. Siehe Fehler beheben.