> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Ajouter Facebook Login natif à votre application iOS

export const HowToSchema = () => <script type="application/ld+json">
    {'{"@context":"https://schema.org","@type":"HowTo"}'}
  </script>;

<HowToSchema />

<div id="before-you-start">
  ## Avant de commencer
</div>

Effectuez les étapes préalables suivantes avant de suivre ce Quickstart :

1. **Configurer le SDK Facebook Login** - Installez et configurez le [SDK Facebook Login pour iOS](https://developers.facebook.com/docs/facebook-login/). Créez une application Facebook sur [developers.facebook.com](https://developers.facebook.com). Une fois terminé, Facebook Login devrait fonctionner dans votre application.
2. **Configurer Auth0 pour Facebook Native** - Configurez votre application Auth0 pour utiliser Facebook Native Sign In. Consultez [Add Facebook Login to Native Apps](/docs/fr-ca/authenticate/identity-providers/social-identity-providers/facebook-native).

<div id="get-started">
  ## Pour commencer
</div>

<Steps>
  <Step title="Configurer les autorisations de Facebook Login" stepNumber={1}>
    Mettez à jour le bouton Facebook Login dans votre `ViewController` pour demander les bonnes autorisations.

    Votre application prend déjà en charge Facebook Login, mais pour obtenir un profil utilisateur plus complet, vous devez demander les autorisations `public_profile` et `email`. Vous ajouterez aussi une fonction de rappel du délégué pour lancer le flux d’authentification Auth0.

    ```swift ViewController.swift lines theme={null}
    import FacebookLogin
    import UIKit

    class ViewController: UIViewController {

        override func viewDidLoad() {
            super.viewDidLoad()

            let fbLoginButton = FBLoginButton()
            // Demander les permissions email et public_profile
            fbLoginButton.permissions = ["email", "public_profile"]
            fbLoginButton.delegate = self
            view.addSubview(fbLoginButton)
        }

        private func performLogin(accessToken: AccessToken) {
            // Les étapes 2 à 4 rempliront ceci
        }
    }

    extension ViewController: LoginButtonDelegate {
        func loginButton(_ loginButton: FBLoginButton, didCompleteWith result: LoginManagerLoginResult?, error: (any Error)?) {
            if let error = error {
                // Gérer l'erreur de connexion Facebook
                print(error)
                return
            }
            if let result = result, let token = result.token {
                performLogin(accessToken: token)
            }
        }

        func loginButtonDidLogOut(_ loginButton: FBLoginButton) {
            // Gérer la déconnexion
        }

        func loginButtonWillLogin(_ loginButton: FBLoginButton) -> Bool {
            return true
        }
    }
    ```

    <Info>
      La permission `email` est facultative — l’utilisateur doit consentir à son partage. L’adresse courriel retournée par Facebook sera **marquée comme non vérifiée** sur le profil utilisateur Auth0.
    </Info>
  </Step>

  <Step title="Installer et configurer le SDK Auth0" stepNumber={2}>
    Ajoutez le SDK Auth0.swift à votre projet et configurez les identifiants de votre application.

    **Ajoutez Auth0.swift avec Swift Package Manager :**

    1. Dans Xcode, accédez à **Fichier** → **Ajouter des dépendances de package...**
    2. Entrez l’URL du package : `https://github.com/auth0/Auth0.swift`
    3. Sélectionnez la version la plus récente, puis cliquez sur **Ajouter le package**

    **Ajoutez vos identifiants Auth0 à `Auth0.plist` :**

    Accédez à la section **Applications** de l’[Auth0 Dashboard](https://manage.auth0.com/) et sélectionnez l’application pour laquelle vous avez activé Facebook Native Sign In. Copiez les valeurs **Domain** et **Client ID**.

    Créez un nouveau fichier de liste de propriétés nommé `Auth0.plist` dans votre projet, puis ajoutez ce qui suit :

    ```xml Auth0.plist lines theme={null}
    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
    <plist version="1.0">
    <dict>
        <key>ClientId</key>
        <string>YOUR_AUTH0_CLIENT_ID</string>
        <key>Domain</key>
        <string>{yourDomain}</string>
    </dict>
    </plist>
    ```

    Faites glisser `Auth0.plist` dans Xcode et assurez-vous que **Add to target** est coché pour la cible de votre application.

    <Tip>
      Le SDK Auth0.swift lit automatiquement les identifiants dans `Auth0.plist`, donc aucun code d’initialisation supplémentaire n’est nécessaire.
    </Tip>
  </Step>

  <Step title="Récupérer le jeton d’accès de la session Facebook" stepNumber={3}>
    Une fois Facebook Login réussi, récupérez un **jeton d’accès de session** à partir de l’API Facebook. Auth0 exige ce jeton pour vérifier l’identité de l’utilisateur dans le backend.

    Faites une requête GET vers le point de terminaison `/oauth/access_token` de Facebook à l’aide de la classe `GraphRequest` :

    ```swift ViewController.swift lines theme={null}
    import FacebookCore

    private func fetchSessionToken(accessToken: AccessToken, completion: @escaping (String?, Error?) -> Void) {
        let request = GraphRequest(graphPath: "oauth/access_token")
        request.parameters["grant_type"] = "fb_attenuate_token"
        request.parameters["client_id"] = facebookAppId()
        request.parameters["fb_exchange_token"] = accessToken.tokenString
        request.start { _, response, error in
            if let error = error {
                completion(nil, error)
                return
            }
            if let responseDict = response as? [String: Any],
               let token = responseDict["access_token"] as? String {
                completion(token, nil)
            }
        }
    }

    private func facebookAppId() -> String? {
        return Bundle.main.infoDictionary?["FacebookAppID"] as? String
    }
    ```

    <Info>
      Les paramètres de requête requis sont :

      * `grant_type` : `fb_attenuate_token`
      * `fb_exchange_token` : la chaîne du jeton provenant de l’`AccessToken` Facebook
      * `client_id` : votre ID d’application Facebook (déjà dans votre `Info.plist` lors de la configuration du Facebook SDK)
    </Info>
  </Step>

  <Step title="Récupérer le profil Facebook de l’utilisateur" stepNumber={4}>
    Récupérez le profil de l’utilisateur sur Facebook. Auth0 utilise ces données pour créer ou mettre à jour le profil de l’utilisateur dans Auth0.

    ```swift ViewController.swift lines theme={null}
    import FacebookCore

    private func fetchUserProfile(completion: @escaping ([String: Any]?, Error?) -> Void) {
        let request = GraphRequest(graphPath: "me")
        request.parameters["fields"] = "first_name,last_name,email"
        request.start { _, result, error in
            if let error = error {
                completion(nil, error)
                return
            }
            if let rawResponse = result as? [String: Any] {
                completion(rawResponse, nil)
            }
        }
    }
    ```

    <Tip>
      Le paramètre `fields` correspond directement aux autorisations Facebook demandées. Il suffit de demander `first_name`, `last_name` et `email` pour qu’Auth0 crée un profil utilisateur complet.
    </Tip>
  </Step>

  <Step title="Échanger des jetons contre des identifiants Auth0" stepNumber={5}>
    Utilisez le jeton de session et le profil utilisateur des étapes précédentes pour vous authentifier avec Auth0 et obtenir des jetons Auth0.

    Appelez `login(facebookSessionAccessToken:profile:audience:scope:)` dans le client d’authentification Auth0 :

    ```swift ViewController.swift lines theme={null}
    import Auth0

    private func exchangeToken(sessionToken: String, userProfile: [String: Any], completion: @escaping (Credentials?, Error?) -> Void) {
        Auth0.authentication()
            .login(
                facebookSessionAccessToken: sessionToken,
                profile: userProfile,
                audience: nil,
                scope: "openid profile email offline_access"
            )
            .start { result in
                switch result {
                case .success(let credentials):
                    completion(credentials, nil)
                case .failure(let error):
                    completion(nil, error)
                }
            }
    }
    ```

    <Info>
      En interne, Auth0.swift utilise le type de jeton `http://auth0.com/oauth/token-type/facebook-info-session-access-token` pour diriger la requête vers la connexion native Facebook.
    </Info>
  </Step>

  <Step title="Tout rassembler" stepNumber={6}>
    Complétez la méthode `performLogin` pour enchaîner les trois étapes : récupérer le jeton de session → récupérer le profil utilisateur → procéder à l’échange contre des jetons Auth0.

    ```swift ViewController.swift lines theme={null}
    private func performLogin(accessToken: AccessToken) {
        fetchSessionToken(accessToken: accessToken) { [weak self] token, error in
            guard let self = self else { return }
            if let error = error {
                print("Session token error:", error)
                return
            }
            guard let token = token else { return }

            self.fetchUserProfile { userProfile, error in
                if let error = error {
                    print("Profile fetch error:", error)
                    return
                }
                guard let userProfile = userProfile else { return }

                self.exchangeToken(sessionToken: token, userProfile: userProfile) { credentials, error in
                    if let error = error {
                        print("Token exchange error:", error)
                        return
                    }
                    if let credentials = credentials {
                        // Authentifié! Stocker les identifiants et mettre à jour l'interface utilisateur
                        print("Access token:", credentials.accessToken)
                    }
                }
            }
        }
    }
    ```

    <Tip>
      Gardez les constantes (permissions Facebook, scopes Auth0) en haut de votre classe pour éviter les chaînes codées en dur. Pensez à utiliser `async/await` pour simplifier les callbacks imbriqués si vous ciblez iOS 15+.
    </Tip>
  </Step>
</Steps>

<Check>
  **Vérification**

  Vous devriez maintenant pouvoir vous authentifier avec Facebook en mode natif. Si l’application Facebook est installée sur l’appareil, l’authentification se fait directement dans l’application — sans navigateur.
</Check>

***

<div id="troubleshooting-advanced">
  ## Dépannage et options avancées
</div>

<Accordion title="Problèmes courants et solutions">
  ### L’échange de jeton échoue avec une erreur d’authentification

  **Solutions :**

  1. Vérifiez que **Facebook Native Sign In** est activé pour votre application Auth0 dans le Dashboard
  2. Vérifiez que `FacebookAppID` dans `Info.plist` correspond à l’App ID dans la console de développement Facebook
  3. Assurez-vous que le fichier `Auth0.plist` est ajouté à la bonne cible dans Xcode
  4. Confirmez que le jeton d’accès Facebook n’a pas expiré avant d’appeler `performLogin`

  ### La requête de jeton de session renvoie une erreur

  **Correctif :**

  * Vérifiez que `FacebookAppID` est correctement défini dans `Info.plist`
  * Assurez-vous que `fb_exchange_token` est bien la chaîne brute du jeton (`accessToken.tokenString`)
  * Vérifiez que votre application Facebook n’est pas en **Development Mode** si vous testez avec des utilisateurs non administrateurs

  ### `AuthenticationError` : "Connection not found"

  **Correctif :**

  1. Accédez à Auth0 Dashboard → **Authentication** → **Social**
  2. Vérifiez que **Sign in with Facebook** est activé
  3. Confirmez que **Facebook Native Social Login** est activé dans les paramètres de la connexion
  4. Vérifiez que l’application Auth0 est associée à la connexion Facebook

  ### Certains champs du profil utilisateur sont manquants

  * Confirmez que `"email"` et `"public_profile"` sont inclus dans le tableau `fbLoginButton.permissions`
  * Il se peut que l’utilisateur ait refusé la permission `email` — gérez ce cas correctement si le courriel est nil
  * Vérifiez que les mêmes champs figurent dans la requête `request.parameters["fields"]` dans `fetchUserProfile`

  ### `Auth0.plist` introuvable

  * Assurez-vous que le nom du fichier est exactement `Auth0.plist` (respect de la casse)
  * Dans Xcode, vérifiez le **Target Membership** du fichier — il doit être inclus dans la cible de votre application
</Accordion>

<Accordion title="Considérations pour la production">
  ### Bonnes pratiques de sécurité

  * **Stockage sécurisé des jetons** : utilisez le `CredentialsManager` d’Auth0.swift pour stocker les jetons de manière sécuritaire dans le Keychain iOS
  * **Refresh tokens** : demandez le scope `offline_access` et utilisez `CredentialsManager` pour actualiser silencieusement les jetons expirés
  * **Protection biométrique** : activez l’authentification biométrique sur `CredentialsManager` pour protéger les informations d’identification stockées

  ### Configuration de l’application Facebook

  * Faites passer votre application Facebook de **Development Mode** à **Live** avant de la publier dans l’App Store
  * Assurez-vous que le Bundle ID de votre application est enregistré dans la console de développement Facebook
  * Consultez les exigences de la [Data Policy](https://developers.facebook.com/policy/) de Facebook pour les applications qui utilisent le Login SDK

  ### Soumission à l’App Store

  * Incluez Facebook Login dans la politique de confidentialité de votre application et dans l’étiquette de confidentialité de l’App Store
  * Gérez les cas où l’utilisateur refuse la permission `email` — votre application devrait fonctionner sans celle-ci
  * Testez sur un appareil réel avant la soumission; le Facebook SDK se comporte différemment dans le simulateur
</Accordion>

<Accordion title="Alternative async/await">
  Si vous ciblez iOS 15+, vous pouvez utiliser async/await pour écrire un code plus clair, sans imbrication :

  ```swift ViewController.swift expandable lines theme={null}
  @MainActor
  private func performLogin(accessToken: AccessToken) async {
      do {
          let sessionToken = try await fetchSessionTokenAsync(accessToken: accessToken)
          let userProfile = try await fetchUserProfileAsync()
          let credentials = try await exchangeTokenAsync(sessionToken: sessionToken, userProfile: userProfile)
          // Authenticated! Store credentials and update UI
          print("Access token:", credentials.accessToken)
      } catch {
          print("Authentication failed:", error)
      }
  }
  ```

  Encapsulez chaque méthode basée sur des callbacks dans un `withCheckedThrowingContinuation` pour faire le pont vers async/await.
</Accordion>

***

<div id="next-steps">
  ## Prochaines étapes
</div>

<CardGroup cols={2}>
  <Card title="Configurer d’autres fournisseurs d’identité" icon="key" href="/docs/fr-ca/authenticate/identity-providers" iconType="solid">
    Ajoutez Google, Apple et d’autres fournisseurs de connexion sociale
  </Card>

  <Card title="Protection contre les attaques" icon="shield" href="/docs/fr-ca/secure/attack-protection" iconType="solid">
    Protégez-vous contre les attaques par force brute et les bots
  </Card>

  <Card title="Actions" icon="bolt" href="/docs/fr-ca/customize/actions/actions-overview" iconType="solid">
    Personnalisez les flux d’authentification avec du code sans serveur
  </Card>

  <Card title="Référence du SDK iOS" icon="apple" href="/docs/fr-ca/libraries/auth0-swift" iconType="solid">
    Explorez la documentation complète du SDK Auth0.swift
  </Card>
</CardGroup>