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

> Maintenir la connexion de l’utilisateur avec Auth0.swift

# Auth0.swift : Enregistrer et renouveler les jetons

Lorsqu’une authentification est effectuée avec la portée `offline_access`, un <Tooltip tip="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau jeton d’accès sans forcer les utilisateurs à se reconnecter." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Refresh+Token">jeton d’actualisation</Tooltip> est renvoyé et peut être utilisé pour demander un nouveau jeton sans avoir à redemander les informations d’identification.

<div id="credentials-manager">
  ## Credentials Manager
</div>

[Auth0.swift](https://github.com/auth0/Auth0.swift) fournit une classe utilitaire qui simplifie le stockage et le renouvellement des identifiants. Vous pouvez accéder aux propriétés `accessToken` et `idToken` à partir de l’instance [Credentials](https://github.com/auth0/Auth0.swift/blob/master/Auth0/Credentials.swift). Il s’agit de la méthode recommandée pour gérer les identifiants des utilisateurs.

Importez d’abord le module `Auth0` :

`import Auth0`

Ensuite, affichez la page <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergée sur l’Authorization Server d’Auth0, afin de vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Universal+Login">Universal Login</Tooltip> :

```swift lines theme={null}
let credentialsManager = CredentialsManager(authentication: Auth0.authentication())

Auth0
    .webAuth()
    .scope("openid profile offline_access")
    .start { result in
        switch result {
        case .success(let credentials):
            // Transmettre les identifiants au gestionnaire d'identifiants
            credentialsManager.store(credentials: credentials)
        case .failure(let error):
            // Gérer l'erreur
        }
}
```

<Warning>
  Les éléments du Keychain ne sont pas supprimés après la désinstallation de votre application. Nous vous recommandons donc de toujours supprimer tous les éléments du Keychain de votre application au premier lancement.
</Warning>

<div id="credentials-check">
  ### Vérification des identifiants
</div>

Il peut être utile d’effectuer une vérification rapide au démarrage de l’application pour s’assurer que des identifiants renouvelables sont enregistrés dans le gestionnaire. Sinon, l’utilisateur peut être redirigé afin de s’authentifier.

```swift lines theme={null}
guard credentialsManager.canRenew() else {
    // Afficher la page de connexion
}
```

<div id="retrieving-user-credentials">
  ### Récupération des identifiants de l’utilisateur
</div>

Vous pouvez récupérer les identifiants de l’utilisateur de la façon suivante :

```swift lines theme={null}
credentialsManager.credentials { result in 
    switch result {
    case .success(let credentials):
        // Identifiants valides ; vous pouvez accéder aux propriétés du jeton comme
        // `idToken`, `accessToken`
    case .failure(let error):
        // Gérer l'erreur, afficher la page de connexion
    }
}
```

Le renouvellement des identifiants d’un utilisateur fonctionne exactement de la même façon si le jeton a expiré. Le Credentials Manager renouvellera automatiquement les identifiants, les stockera dans le Keychain, puis retournera un `Result` contenant soit les identifiants, soit une erreur.

<div id="alternative-method-simplekeychain">
  ## Méthode alternative - SimpleKeychain
</div>

Cette section s’adresse aux développeurs qui préfèrent ne pas utiliser le Credentials Manager. Nous incluons l’utilitaire SimpleKeychain –une légère couche au-dessus du Keychain du système– qui peut servir à stocker les jetons de façon sécuritaire.

Importez d’abord le module `SimpleKeychain` :

`import SimpleKeychain`

Ensuite, créez une instance et stockez les jetons dont vous avez besoin. Dans ce cas-ci, vous stockerez le `access_token` et le `refresh_token` dans le Keychain après une authentification réussie.

```swift lines theme={null}
let keychain = SimpleKeychain(service: "Auth0")

Auth0
    .webAuth()
    .scope("openid profile offline_access")
    .start { result in
        switch result {
        case .success(let credentials):
            guard let refreshToken = credentials.refreshToken else { 
                // Gérer l'erreur 
                return
            }
            // Stocker les jetons
            do {
                try keychain.set(credentials.accessToken, forKey: "access_token")
                try keychain.set(refreshToken, forKey: "refresh_token")
            } catch {
                // Gérer l'erreur
            }
            // Vous voudrez peut-être rediriger vers le flux principal de votre application à ce stade
        case .failure(let error):
            // Gérer l'erreur
        }
}
```

Une fois qu’elles sont enregistrées, vous pouvez à tout moment demander une nouvelle instance de [Credentials](https://github.com/auth0/Auth0.swift/blob/master/Auth0/Credentials.swift).

<div id="renewing-user-credentials">
  ### Renouvellement des identifiants de l’utilisateur
</div>

```swift lines expandable theme={null}
let keychain = SimpleKeychain(service: "Auth0")

Auth0
    .authentication()
    .renew(withRefreshToken: refreshToken)
    .start { result in
        switch(result) {
        case .success(let credentials):
            // Si la rotation des jetons d'actualisation est activée, vous obtenez un 
            // nouveau jeton d'actualisation
            // Sinon, vous obtenez uniquement un nouveau jeton d'accès
            guard let refreshToken = credentials.refreshToken else { 
                // Gérer l'erreur 
                return
            }
            // Enregistrer les nouveaux jetons
            do {
                try keychain.set(credentials.accessToken, forKey: "access_token")
                try keychain.set(refreshToken, forKey: "refresh_token")
            } catch {
                // Gérer l'erreur
            }
        case .failure(let error):
            // Gérer l'erreur
        }
}
```