Facebook Login einrichten

Einführung

In diesem Guide lernst du, wie du Facebook Login mit Capgo Social Login einrichtest. Du benötigst Folgendes:

• Ein Facebook Developer Account
• Den Package Name/Bundle ID deiner App
• Terminal-Zugriff zum Generieren von Key Hashes (Android)

Allgemeine Einrichtung

Falls du noch keine Facebook-App erstellt hast, folge diesen Schritten:

1. Facebook-App erstellen

   Folge dem Tutorial, um eine App zu erstellen

2. Facebook Login zu deiner App hinzuzufügen

   Füge in deinem Facebook Developer Dashboard das Produkt Facebook Login zu deiner App hinzu

3. Bevor du deine App veröffentlichen kannst, folge diesem Tutorial um sie zu publizieren

Wichtige Informationen

Hier findest du die wichtigsten Informationen für die Integration:

1. CLIENT_TOKEN:

   

2. APP_ID:

   

3. APP_NAME:

   

Facebook Business Login

Dieses Plugin unterstützt Facebook Business Login für geschäftsspezifische Features und Berechtigungen. Business-Accounts können zusätzliche Berechtigungen über den Standard-Consumer-Login hinaus anfordern, einschließlich der Verwaltung von Instagram und Pages.

Unterstützte Business-Berechtigungen sind:

• instagram_basic - Zugriff auf Instagram Basic Display API
• instagram_manage_insights - Zugriff auf Instagram Insights
• pages_show_list - Liste der verwalteten Pages
• pages_read_engagement - Engagement-Daten von Pages lesen
• pages_manage_posts - Posts auf Pages verwalten
• business_management - Business-Assets verwalten

Siehe den Facebook-Berechtigungen im Überblick für die vollständige Liste der Berechtigungen.

Konfigurationsanforderungen:

1. Deine Facebook-App muss in der Facebook Developer Console als Business-App konfiguriert sein.
2. Business-Berechtigungen erfordern eventuell einen Facebook App Review vor der produktiven Nutzung.
3. Deine App muss den Facebook Business Use Case Richtlinien entsprechen.

Instagram Basic Access

await SocialLogin.initialize({
  facebook: {
    appId: 'your-business-app-id',
    clientToken: 'your-client-token',
  },
});

const res = await SocialLogin.login({
  provider: 'facebook',
  options: {
    permissions: [
      'email',
      'public_profile',
      'instagram_basic',
      'pages_show_list',
      'pages_read_engagement',
    ],
  },
});

const profile = await SocialLogin.providerSpecificCall({
  call: 'facebook#getProfile',
  options: {
    fields: ['id', 'name', 'email', 'instagram_business_account'],
  },
});

Pages-Verwaltung

const res = await SocialLogin.login({
  provider: 'facebook',
  options: {
    permissions: [
      'email',
      'pages_show_list',
      'pages_manage_posts',
      'pages_read_engagement',
    ],
  },
});

const profile = await SocialLogin.providerSpecificCall({
  call: 'facebook#getProfile',
  options: {
    fields: ['id', 'name', 'accounts{id,name,instagram_business_account}'],
  },
});

Wichtige Hinweise:

• Du kannst Business-Berechtigungen vor dem App Review mit Test-Usern und Development-Apps testen.
• Die meisten Business-Berechtigungen erfordern ein Facebook App Review vor der produktiven Nutzung.
• Business-APIs haben unterschiedliche Rate Limits. Prüfe die aktuelle Facebook-Dokumentation vor dem Launch.
• Folge dem Facebook Business Integrations-Leitfaden bei der Konfiguration der App.

Android-Setup

1. Füge die Internet-Berechtigung zu deiner AndroidManifest.xml

   Stelle sicher, dass diese Zeile vorhanden ist:

   <uses-permission android:name="android.permission.INTERNET"/>

2. Generiere deinen Android Key Hash

   Dies ist ein wichtiger Sicherheitsschritt, den Facebook voraussetzt. Öffne dein Terminal und führe aus:

   keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore | openssl sha1 -binary | openssl base64 -A

   Gib bei der Passwortabfrage Folgendes ein: android

   Hinweis

   Für Release-Builds musst du deinen Release-Keystore verwenden:

   keytool -exportcert -alias your-key-name -keystore your-keystore-path | openssl sha1 -binary | openssl base64 -A

3. Füge den Key Hash zu deiner Facebook-App hinzu

   1. Gehe zum Dashboard deiner App bei Facebook Developers
   2. Navigiere zu Einstellungen > Grundlegendes
   3. Scrolle nach unten zum Bereich „Android“
   4. Klicke auf „Plattform hinzufügen“, falls Android noch nicht hinzugefügt ist, und trage die Details ein
   5. Füge den generierten Key Hash hinzu
   6. Füge für die Produktion sowohl Debug- als auch Release-Key-Hashes hinzu

4. Aktualisiere dein AndroidManifest.xml Zum Einbinden:

   <application>
       ...
       <activity android:name="com.facebook.FacebookActivity"
           android:configChanges="keyboard|keyboardHidden|screenLayout|screenSize|orientation"
           android:label="@string/app_name" />
   
       <activity
           android:name="com.facebook.CustomTabActivity"
           android:exported="true">
           <intent-filter>
               <action android:name="android.intent.action.VIEW" />
               <category android:name="android.intent.category.DEFAULT" />
               <category android:name="android.intent.category.BROWSABLE" />
               <data android:scheme="FB[APP_ID]" />
           </intent-filter>
       </activity>
   </application>

   Achtung

   Achte darauf, dies zu ersetzen [APP_ID] durch deine tatsächliche Facebook App ID im android:scheme Attribut

iOS-Setup

1. Füge die iOS-Plattform in der Facebook Developer Console hinzu

   1. Gehe zum Dashboard deiner App bei Facebook Developers
   2. Navigiere zu Einstellungen > Grundlegendes
   3. Scrolle auf der Seite ganz nach unten und klicke auf „Add Platform“
   4. Wähle iOS aus und fülle die erforderlichen Details aus

2. Öffne dein Xcode-Projekt und navigiere zur Info.plist

3. Füge die folgenden Einträge zu deiner Info.plist hinzu:

   <key>FacebookAppID</key>
   <string>[APP-ID]</string>
   <key>FacebookClientToken</key>
   <string>[CLIENT-TOKEN]</string>
   <key>FacebookDisplayName</key>
   <string>[APP-NAME]</string>
   <key>LSApplicationQueriesSchemes</key>
   <array>
       <string>fbapi</string>
       <string>fb-messenger-share-api</string>
   </array>
   <key>CFBundleURLTypes</key>
   <array>
       <dict>
           <key>CFBundleURLSchemes</key>
           <array>
               <string>fb[APP-ID]</string>
           </array>
       </dict>
   </array>

   Achtung

   Ersetze die folgenden Werte:

   • [APP-ID] durch deine Facebook App ID
   • [CLIENT-TOKEN] durch deinen Client Token
   • [APP-NAME] durch den Namen deiner App

4. Ändere die AppDelegate.swift

   import FBSDKCoreKit
   @UIApplicationMain
   class AppDelegate: UIResponder, UIApplicationDelegate {
         func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
           // Override point for customization after application launch.
   
           // Initialize Facebook SDK
           FBSDKCoreKit.ApplicationDelegate.shared.application(
               application,
               didFinishLaunchingWithOptions: launchOptions
           )
   
           return true
       }
   
       func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
           // Called when the app was launched with a url. Feel free to add additional processing here,
           // but if you want the App API to support tracking app url opens, make sure to keep this call
   
           if (FBSDKCoreKit.ApplicationDelegate.shared.application(
               app,
               open: url,
               sourceApplication: options[UIApplication.OpenURLOptionsKey.sourceApplication] as? String,
               annotation: options[UIApplication.OpenURLOptionsKey.annotation]
           )) {
               return true;
           } else {
               return ApplicationDelegateProxy.shared.application(app, open: url, options: options)
           }
       }
   }

Facebook Login in deiner App nutzen

Achtung

Bevor du startest: Denk daran: Beim neuen Facebook SDK hängt der Token-Typ, den du erhältst, komplett von der App-Tracking-Entscheidung des Nutzers ab, nicht von deiner code Konfiguration. Implementiere in deinem Backend immer sowohl Access-Token- als auch JWT-Token-Handling, damit die Authentifizierung für alle Nutzer funktioniert.

1. Facebook-Login in deiner App initialisieren

   import { SocialLogin } from '@capgo/capacitor-social-login';
   
   // Initialize during app startup
   await SocialLogin.initialize({
     facebook: {
       appId: 'APP_ID',
       clientToken: 'CLIENT_TOKEN',
     }
   })

2. Login-Funktion implementieren

   async function loginWithFacebook() {
     try {
       const result = await SocialLogin.login({
         provider: 'facebook',
        options: {
          permissions: ['email', 'public_profile'],
          limitedLogin: false // See Limited Login section below for important details
        }
       });
       console.log('Facebook login result:', result);
       // Handle successful login
     } catch (error) {
       console.error('Facebook login error:', error);
       // Handle error
     }
   }

   Hinweis

   Limited Login (nur iOS): Setze limitedLogin auf true, wenn du das Facebook Limited Login Feature nutzen möchtest. Dies ist eine iOS-exklusive Funktion, die durch eingeschränkten Datenaustausch beim Login für mehr Privatsphäre sorgt.

   Wichtige Einschränkungen:

   • Nur iOS: Limited Login betrifft nur iOS-Geräte und wirkt sich nicht auf Android aus
   • ATT-Override: Selbst wenn du limitedLogin: false, setzt Facebook es automatisch auf true , falls der Nutzer die App Tracking Transparency (ATT)-Berechtigung nicht erteilt hat
   • Immer beide Fälle behandeln: Deine App sollte immer sowohl Limited- als auch Full-Login-Szenarien behandeln können

   ATT-Status prüfen:

   // Check if user has granted tracking permission
   const trackingStatus = await SocialLogin.providerSpecificCall({
     call: 'facebook#requestTracking',
     options: {}
   });
   console.log('Tracking status:', trackingStatus.status); // 'authorized', 'denied', 'notDetermined', or 'restricted'

   Empfohlene Implementierung, falls access_token bevorzugt wird:

   async function loginWithFacebook() {
     try {
       // Check ATT status first
       const trackingStatus = await SocialLogin.providerSpecificCall({
         call: 'facebook#requestTracking',
         options: {}
       });
   
       const result = await SocialLogin.login({
         provider: 'facebook',
         options: {
           permissions: ['email', 'public_profile'],
           limitedLogin: trackingStatus.status === 'denied' // Auto-adjust based on ATT
         }
       });
   
       // Handle different response types based on limited login
       if (result.result.accessToken) {
         // Your app logic should work with both limited and full login
         console.log('Login successful:', result);
       }
     } catch (error) {
       console.error('Facebook login error:', error);
     }
   }

   Was beim Limited Login passiert:

   • Reduzierter Datenzugriff: Einige Benutzerdaten sind eventuell nicht verfügbar
   • Unterschiedliche Token-Typen: Access Tokens können unterschiedliche Berechtigungen haben
   • Datenschutz-Compliance: Hilft bei der Einhaltung der iOS-Datenschutzanforderungen

   Wichtig: Teste deine App immer sowohl mit Limited Login als auch mit vollem Login, um sicherzustellen, dass sie in beiden Fällen korrekt funktioniert. Mehr Infos zum Limited Login findest du hier hier.

3. Benutzerprofil-Daten abrufen

   Nach dem erfolgreichen Login kannst du weitere Profilinformationen abrufen:

   async function getFacebookProfile() {
     try {
       const profileResponse = await SocialLogin.providerSpecificCall({
         call: 'facebook#getProfile',
         options: {
           fields: ['id', 'name', 'email', 'first_name', 'last_name', 'picture']
         }
       });
   
       console.log('Facebook profile:', profileResponse.profile);
       return profileResponse.profile;
     } catch (error) {
       console.error('Failed to get Facebook profile:', error);
       return null;
     }
   }
   
   // Example usage after login
   async function loginAndGetProfile() {
     const loginResult = await loginWithFacebook();
     if (loginResult) {
       const profile = await getFacebookProfile();
       if (profile) {
         console.log('User ID:', profile.id);
         console.log('Name:', profile.name);
         console.log('Email:', profile.email);
         console.log('Profile Picture:', profile.picture?.data?.url);
       }
     }
   }

   Tipp

   Verfügbare ProfilfelderDu kannst alle verfügbaren Felder aus der Facebook Graph API anfordern. Häufig genutzte Felder sind: id, name, email, first_name, last_name, picture, birthday, gender, location, hometown. Beachte, dass einige Felder zusätzliche Berechtigungen erfordern können.

   Einschränkung des Token-Typs: Das getProfile funktioniert nur, wenn du einen Access Token (Standard-Login mit Tracking erlaubt) hast. Wenn der User Tracking abgelehnt hat oder du Limited Login (nur JWT-Token) nutzt, schlägt dieser Aufruf fehl. Nutze in diesem Fall die Profil-Daten aus der initialen Login-Response.

⚠️ Kritisch: Backend-Token-Handling

Achtung

KRITISCHES iOS-VERHALTEN: Limited Login und App Tracking Transparency (ATT) sind NUR FÜR iOS Features. Unter Android erhältst du immer Access Tokens, unabhängig von der limitedLogin Einstellung.

iOS Token-Verhalten:

• limitedLogin: true → Immer JWT-Token (nur iOS)
• limitedLogin: false + User erlaubt Tracking → Access Token
• limitedLogin: false + User lehnt Tracking ab → JWT Token (iOS überschreibt deine Einstellung automatisch)

Token-Verhalten unter Android: Immer Access Token, limitedLogin die Einstellung wird ignoriert.

Dein Backend muss zwei verschiedene Token-Typen verarbeiten, da iOS-Nutzer je nach ihrer Entscheidung bei App Tracking Transparency entweder Access Tokens oder JWT Tokens erhalten, während Android-Nutzer immer Access Tokens bekommen.

Token-Typen nach Plattform

Plattform	limitedLogin-Einstellung	ATT-Entscheidung des Nutzers	Resultierender Token-Typ
iOS	true	Beliebig	JWT-Token
iOS	false	Tracking erlaubt	Access-Token
iOS	false	Tracking verweigert	JWT-Token (Auto-Override)
Android	Beliebig	n. v.	Access Token (immer)

Backend-Implementierung

1. Token-Typ erkennen und verarbeiten

   async function loginWithFacebook() {
     try {
       const loginResult = await SocialLogin.login({
         provider: 'facebook',
         options: {
           permissions: ['email', 'public_profile'],
           limitedLogin: false // iOS: depends on ATT, Android: ignored
         }
       });
   
       if (loginResult.accessToken) {
         // Access token (Android always, iOS when tracking allowed)
         return handleAccessToken(loginResult.accessToken.token);
       } else if (loginResult.idToken) {
         // JWT token (iOS only when tracking denied or limitedLogin: true)
         return handleJWTToken(loginResult.idToken);
       }
     } catch (error) {
       console.error('Facebook login error:', error);
     }
   }

2. Beispiel: Firebase-Integration

   import { OAuthProvider, FacebookAuthProvider, signInWithCredential } from 'firebase/auth';
   
   async function handleAccessToken(accessToken: string, nonce: string) {
     // For access tokens, use OAuthProvider (new method)
     const fbOAuth = new OAuthProvider("facebook.com");
     const credential = fbOAuth.credential({
       idToken: accessToken,
       rawNonce: nonce
     });
   
     try {
       const userResponse = await signInWithCredential(auth, credential);
       return userResponse;
     } catch (error) {
       console.error('Firebase OAuth error:', error);
       return false;
     }
   }
   
   async function handleJWTToken(jwtToken: string) {
     // For JWT tokens, send to your backend for validation
     try {
       const response = await fetch('/api/auth/facebook-jwt', {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
         },
         body: JSON.stringify({ jwtToken })
       });
   
       const result = await response.json();
       return result;
     } catch (error) {
       console.error('JWT validation error:', error);
       return false;
     }
   }

3. Backend JWT-Validierung

   // Backend: Validate JWT token from Facebook
   import jwt from 'jsonwebtoken';
   import { Request, Response } from 'express';
   
   app.post('/api/auth/facebook-jwt', async (req: Request, res: Response) => {
     const { jwtToken } = req.body;
   
     try {
       // Verify JWT token with Facebook's public key
       // See: https://developers.facebook.com/docs/facebook-login/limited-login/token/validating/#standard-claims
       const decoded = jwt.verify(jwtToken, getFacebookPublicKey(), {
         algorithms: ['RS256'],
         audience: process.env.FACEBOOK_APP_ID,
         issuer: 'https://www.facebook.com' // From: https://www.facebook.com/.well-known/openid-configuration/?_rdr
       });
   
       // Extract user info from JWT
       const userInfo = {
         id: decoded.sub,
         email: decoded.email,
         name: decoded.name,
         isJWTAuth: true
       };
   
       // Create your app's session/token
       const sessionToken = createUserSession(userInfo);
   
       res.json({
         success: true,
         token: sessionToken,
         user: userInfo
       });
     } catch (error) {
       console.error('JWT validation failed:', error);
       res.status(401).json({ success: false, error: 'Invalid token' });
     }
   });

4. Allgemeiner Backend-Token-Handler

   // Handle both token types in your backend
   async function authenticateFacebookUser(tokenData: any) {
     if (tokenData.accessToken) {
       // Handle access token - validate with Facebook Graph API
       const response = await fetch(`https://graph.facebook.com/me?access_token=${tokenData.accessToken}&fields=id,name,email`);
       const userInfo = await response.json();
   
       return {
         user: userInfo,
         tokenType: 'access_token',
         expiresIn: tokenData.expiresIn || 3600
       };
     } else if (tokenData.jwtToken) {
       // Handle JWT token - decode and validate
       // See: https://developers.facebook.com/docs/facebook-login/limited-login/token/validating/#standard-claims
       const decoded = jwt.verify(tokenData.jwtToken, getFacebookPublicKey());
   
       return {
         user: {
           id: decoded.sub,
           name: decoded.name,
           email: decoded.email
         },
         tokenType: 'jwt',
         expiresIn: decoded.exp - Math.floor(Date.now() / 1000)
       };
     } else {
       throw new Error('No valid token provided');
     }
   }

Wichtige Aspekte

Achtung

Wichtige Informationen (nur iOS):

• iOS: Die App-Tracking-Entscheidung des Nutzers bestimmt den Token-Typ, NICHT deine code Einstellungen (selbst wenn limitedLogin: false)
• Android: Erhält immer Access-Token, unabhängig von der limitedLogin Einstellung
• Limited Login ist nur für iOS verfügbar - Android ignoriert diese Einstellung komplett

Access Token (Standard-Login):

• ✅ Android: Immer verfügbar (iOS-Einschränkungen gelten nicht)
• ✅ iOS: Nur wenn der User App-Tracking explizit erlaubt
• ✅ Zugriff auf Facebook Graph API möglich
• ✅ Längere Expiration-Zeiten
• ✅ Mehr User-Daten verfügbar
• ❌ Wird unter iOS seltener da User Tracking immer häufiger ablehnen

JWT-Token (iOS-only Privacy Mode):

• ❌ Android: Tritt nie auf (nicht unterstützt)
• ✅ iOS: Wenn Tracking abgelehnt wurde oder limitedLogin: true
• ✅ Beachtet iOS-Datenschutzeinstellungen
• ❌ Enthält nur Basis-Nutzerinfos
• ❌ Kürzere Expiration-Zeiten
• ❌ Kein Zugriff auf Facebook Graph API
• ⚠️ Aktuell das häufigste Szenario für iOS-Nutzer

Plattformspezifisches Verhalten:

• iOS-Apps: Muss sowohl Access Tokens ALS AUCH JWT-Tokens verarbeiten
• Android-Apps: Muss nur Access Tokens verarbeiten
• Cross-Platform-Apps: Muss beide Token-Handling-Methoden implementieren

Tipp

Essenziell für iOS: Du MUSST beide Token-Handling-Methoden implementieren. Viele iOS-Entwickler gehen davon aus, dass sie immer Access Tokens erhalten, doch ihre Apps versagen, sobald Nutzer das Tracking ablehnen.

Secure-Context-Anforderungen (Web/Capacitor)

Crypto API Einschränkungen

Der aktualisierte Facebook-Login-Flow benötigt Web Crypto API für die Nonce-Generierung, die nur in sicheren Kontexten verfügbar ist:

// This requires secure context (HTTPS or localhost)
async function sha256(message: string) {
  const msgBuffer = new TextEncoder().encode(message);
  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer); // ❌ Fails in insecure context
  // ...
}

Probleme mit der Entwicklungsumgebung

Häufiges Problem: ionic serve mit HTTP-URLs bricht die Facebook-Authentifizierung

Umgebung	Crypto API verfügbar	Facebook Login funktioniert
http://localhost:3000	✅ Ja	✅ Ja
http://127.0.0.1:3000	✅ Ja	✅ Ja
http://192.168.1.100:3000	❌ Nein	❌ Nein
https://any-domain.com	✅ Ja	✅ Ja

Lösungen für die Capacitor-Entwicklung

1. Nutze localhost für Web-Tests

   # Instead of ionic serve --host=0.0.0.0
   ionic serve --host=localhost

2. HTTPS in Ionic aktivieren

   ionic serve --ssl

3. Auf echten Geräten testen

   # Capacitor apps run in secure context on devices
   ionic cap run ios
   ionic cap run android

4. Alternative Nonce-Generierung für die Entwicklung

   async function generateNonce() {
     if (typeof crypto !== 'undefined' && crypto.subtle) {
       // Secure context - use crypto.subtle
       return await sha256(Math.random().toString(36).substring(2, 10));
     } else {
       // Fallback for development (not secure for production)
       console.warn('Using fallback nonce - not secure for production');
       return btoa(Math.random().toString(36).substring(2, 10));
     }
   }

Hinweis zur Firebase-Integration

Die aktuelle Firebase-Dokumentation erfordert für die Facebook-Authentifizierung JWT-Token mit Nonces, unabhängig von den Login-Einstellungen. Dieser Ansatz funktioniert sowohl mit limitedLogin: true und limitedLogin: false:

   // Both modes can return JWT tokens depending on user choice
   const loginResult = await SocialLogin.login({
     provider: 'facebook',
     options: {
       permissions: ['email', 'public_profile'],
       limitedLogin: false, // true = always JWT, false = depends on user tracking choice
       nonce: nonce
     }
   });

Einschränkung in der Entwicklung: If you’re using ionic serve über eine Netzwerk-IP (nicht localhost) nutzt, schlägt der Facebook-Login aufgrund von Einschränkungen bei Crypto API fehl. Nutze localhost oder HTTPS für Web-Tests.

Tipp

Produktionssicherheit: Capacitor Apps auf iOS/Android laufen immer in sicheren Kontexten, sodass diese Einschränkung nur Web-Entwicklungsumgebungen betrifft.

Fehlerbehebung

Häufige Probleme und Lösungen

1. Key-Hash-Fehler unter Android

   • Prüfe, ob du den richtigen Key-Hash im Facebook-Dashboard hinterlegt hast
   • Füge bei Release-Builds sowohl den Debug- als auch den Release-Key-Hash hinzu
   • Stelle sicher, dass du beim Generieren des Hashs den richtigen Keystore verwendest

2. Facebook-Login-Button wird nicht angezeigt

   • Überprüfe, ob alle Manifest-Einträge korrekt sind
   • Prüfe, ob deine Facebook App ID und dein Client Token stimmen
   • Stelle sicher, dass du SDK korrekt initialisiert hast

3. Häufige iOS-Probleme

   • Stelle sicher, dass alle Info.plist-Einträge korrekt sind
   • Prüfen, ob URL-Schemes korrekt konfiguriert sind
   • Prüfen, ob die Bundle ID mit dem Facebook Dashboard übereinstimmt

Testen

1. Vor dem Testen Test-User in der Facebook Developer Console anlegen

   • Navigiere zu Roles > Test Users
   • Einen Test-User erstellen
   • Diese Credentials für Tests verwenden

2. Sowohl Debug- als auch Release-Builds testen

   • Debug-Build mit Debug-Key-Hash
   • Release-Build mit Release-Key-Hash
   • Auf Emulatoren und echten Geräten testen

Vergiss nicht, den gesamten Login-Flow zu testen, inklusive:

• Erfolgreicher Login
• Login-Abbruch
• Fehlerbehandlung
• Logout-Funktionalität

Weiter nach dem Facebook Login Setup

Wenn du es nutzt Facebook Login einrichten Um Authentifizierungs- und Account-Flows zu planen, verbinde es mit @capgo/capacitor-social-login verwenden für die native Funktion bei der Verwendung von @capgo/capacitor-social-login, @capgo/capacitor-social-login für die Implementierungsdetails in @capgo/capacitor-social-login, @capgo/capacitor-passkey für die Implementierungsdetails in @capgo/capacitor-passkey, @capgo/capacitor-native-biometric für die Implementierungsdetails in @capgo/capacitor-native-biometric, und Zwei-Faktor-Authentifizierung für die Implementierungsdetails zur Zwei-Faktor-Authentifizierung.