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

# Ajouter Facebook Login natif à votre application iOS

## Avant de commencer

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](https://auth0.com/docs/fr-ca/authenticate/identity-providers/social-identity-providers/facebook-native.md).

## Pour commencer

**1. Configurer les autorisations de Facebook Login**

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
    }
}
```

> [!NOTE]
>
> 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.

**2. Installer et configurer le SDK Auth0**

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.

**3. Récupérer le jeton d’accès de la session Facebook**

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
}
```

> [!NOTE]
>
> 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)

**4. Récupérer le profil Facebook de l’utilisateur**

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.

**5. Échanger des jetons contre des identifiants Auth0**

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)
            }
        }
}
```

> [!NOTE]
>
> 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.

**6. Tout rassembler**

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]
>
> **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.

***

## Dépannage et options avancées

> **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

> **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

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

***

## Prochaines étapes

> **[Configurer d’autres fournisseurs d’identité](https://auth0.com/docs/fr-ca/authenticate/identity-providers)**
>
> Ajoutez Google, Apple et d’autres fournisseurs de connexion sociale

> **[Protection contre les attaques](https://auth0.com/docs/fr-ca/secure/attack-protection.md)**
>
> Protégez-vous contre les attaques par force brute et les bots

> **[Actions](https://auth0.com/docs/fr-ca/customize/actions/actions-overview.md)**
>
> Personnalisez les flux d’authentification avec du code sans serveur

> **[Référence du SDK iOS](https://auth0.com/docs/fr-ca/libraries/auth0-swift)**
>
> Explorez la documentation complète du SDK Auth0.swift