Mit GitHub auf Apple-Plattformen authentifizieren

Sie können Ihre Nutzer über OAuth-Anbieter wie GitHub mit Firebase authentifizieren, indem Sie mit dem Firebase SDK eine generische OAuth-Anmeldung in Ihre App einbinden, um den End-to-End-Anmeldevorgang durchzuführen.

Hinweis

Wenn Sie Nutzer mit GitHub-Konten anmelden möchten, müssen Sie zuerst GitHub für die Anmeldung aktivieren für Ihr Firebase-Projekt erstellen:

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

Sehen Sie sich unsere Installationsanleitung an. erfahren Sie mehr über die verschiedenen Möglichkeiten, wie Sie Firebase SDKs zu Ihrem Apple-Projekt hinzufügen können, z. B. direkt importieren und mit CocoaPods arbeiten.

1. Gehen Sie in Xcode bei geöffnetem App-Projekt zu File > 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 standardmäßige (neueste) SDK-Version verwenden. Sie können wählen Sie bei Bedarf eine ältere Version aus.
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.

Führen Sie nun einige Konfigurationsschritte aus:

1. Öffnen Sie in der Firebase-Konsole den Abschnitt Auth.
2. Aktivieren Sie auf dem Tab Anmeldemethode den GitHub-Anbieter.
3. Fügen Sie die Client-ID und den Clientschlüssel aus der Entwicklerkonsole dieses Anbieters zum Anbieterkonfiguration:
   1. Registrieren Sie Ihre App als Entwickleranwendung auf GitHub und rufen Sie die OAuth 2.0-Client-ID und das Client-Secret Ihrer App ab.
   2. Achten Sie darauf, dass der OAuth-Weiterleitungs-URI von Firebase (z. B. my-app-12345.firebaseapp.com/__/auth/handler) in der Konfigurationsdatei Ihrer GitHub-App auf der Seite „Einstellungen“ Ihrer App als Callback-URL für die Autorisierung festgelegt ist.
4. Klicken Sie auf Speichern.

Anmeldevorgang mit dem Firebase SDK abwickeln

So verwalten Sie den Anmeldevorgang mit dem Firebase SDK für Apple-Plattformen:

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

      Wenn die Konfiguration abgeschlossen ist, sollte sie in etwa so aussehen wie die (aber mit Ihren anwendungsspezifischen Werten):

      

2. Instanz eines OAuthProviders mithilfe der Anbieter-ID erstellen github.com

   Swift

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

   Objective-C

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

3. Optional: Geben Sie zusätzliche benutzerdefinierte OAuth-Parameter an, die Sie mit der OAuth-Anfrage senden.

   Swift

       provider.customParameters = [
         "allow_signup": "false"
       ]
       

   Objective-C

       [provider setCustomParameters:@{@"allow_signup": @"false"}];
       

   Die von GitHub unterstützten Parameter finden Sie im GitHub-OAuth-Dokumentation 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.

4. Optional: Geben Sie über das Basisprofil hinaus zusätzliche OAuth 2.0-Bereiche an, den Sie beim Authentifizierungsanbieter anfordern möchten. Wenn Ihre Anwendung Zugriff auf private Nutzerdaten aus GitHub-APIs benötigt, müssen Sie in der GitHub-Entwicklerkonsole unter API-Berechtigungen Berechtigungen für den Zugriff auf GitHub-APIs anfordern. Die angeforderten OAuth-Bereiche müssen genau mit den vorkonfigurierten Bereichen in den API-Berechtigungen der App übereinstimmen.

   Swift

       // Request read access to a user's email addresses.
       // This must be preconfigured in the app's API permissions.
       provider.scopes = ["user:email"]
       

   Objective-C

       // Request read access to a user's email addresses.
       // This must be preconfigured in the app's API permissions.
       [provider setScopes:@[@"user:email"]];
       

   Weitere Informationen finden Sie im Dokumentation zu GitHub-Bereichen

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

6. Authentifizierung mit Firebase über das OAuth-Anbieterobjekt

   Swift

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

   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.
   
             FIROAuthCredential *oauthCredential = (FIROAuthCredential *)authResult.credential;
             // GitHub OAuth access token can also be retrieved by:
             // oauthCredential.accessToken
             // GitHub OAuth ID token can be retrieved by calling:
             // oauthCredential.idToken
           }];
         }
       }];
       

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

   Wenn du beispielsweise grundlegende Profilinformationen abrufen möchtest, kannst du die REST API aufrufen und das Zugriffstoken im Authorization-Header übergeben:

   https://api.github.com/user
   

7. Die obigen Beispiele konzentrieren sich zwar auf Anmeldeabläufe, Sie haben aber auch die Möglichkeit, Möglichkeit, einen GitHub-Anbieter mit einem vorhandenen Nutzer zu verknüpfen So können Sie zum Beispiel Verknüpfen mehrerer Anbieter mit demselben Nutzer, sodass sich diese über beide anmelden können.

   Swift

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

   Objective-C

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

8. Dasselbe Muster kann mit reauthenticateWithCredential verwendet werden, um aktuelle Anmeldedaten für vertrauliche Vorgänge abzurufen, für die eine aktuelle Anmeldung erforderlich ist.

   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
         // GitHub OAuth ID token can be retrieved by calling:
         // (authResult.credential as? OAuthCredential)?.idToken
       }
       

   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
         // GitHub OAuth ID token can be retrieved by calling:
         // ((FIROAuthCredential *)authResult.credential).idToken
       }];
       

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, Wenn ein Nutzer versucht, sich mit einer E-Mail-Adresse bei einem Anbieter wie GitHub 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 (GitHub-Anmeldedaten). Um die Anmeldung beim gewünschten Anbieter abzuschließen, muss sich der Nutzer zuerst beim bestehenden Anbieter (Google) anmelden und dann eine Verknüpfung zum ehemaligen FIRAuthCredential (GitHub-Anmeldedaten) herstellen. Das würde dann so aussehen:

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 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 Anmeldedaten des Authentifizierungsanbieters mit einem vorhandenen Nutzerkonto verknüpfen.

Rufen Sie auf, um einen Nutzer abzumelden. signOut:

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. Weitere Informationen finden Sie unter Fehler behandeln.