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

# Auth0.swift : Enregistrement et renouvellement des jetons

> Garder votre utilisateur connecté avec Auth0.swift

Lorsqu’une authentification est effectuée avec la permission `offline_access` incluse, elle renvoie un jeton d’actualisation qui peut être utilisé pour demander un nouveau jeton sans avoir à redemander les identifiants.

## Gestionnaire des identifiants

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

Importez d’abord le module `Auth0`.

`import Auth0`

Présentez ensuite la page de connexion universelle :

```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):
            // Pass the credentials over to the Credentials Manager
            credentialsManager.store(credentials: credentials)
        case .failure(let error):
            // Handle error
        }
}
```

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

### Vérification des identifiants

Il peut être utile d’effectuer une vérification rapide au démarrage de l’application pour s’assurer que les identifiants renouvelables sont bien stockés dans le gestionnaire. Si ce n’est pas le cas, l’utilisateur peut alors être invité à s’authentifier.

```swift lines theme={null}
guard credentialsManager.canRenew() else {
    // Present login page
}
```

### Récupération des identifiants utilisateur

Vous pouvez récupérer les identifiants utilisateur de la manière suivante :

```swift lines theme={null}
credentialsManager.credentials { result in 
    switch result {
    case .success(let credentials):
        // Valid credentials; you can access token properties such as
        // `idToken`, `accessToken`
    case .failure(let error):
        // Handle error, present login page
    }
}
```

Pour renouveler les identifiants d’un utilisateur, il faut procéder de la même manière que lorsque le jeton a expiré. Le Gestionnaire des identifiants renouvelle automatiquement les identifiants, les enregistre dans le trousseau, puis renvoie un `Result` contenant soit les identifiants, soit une erreur.

## Autre méthode - SimpleKeychain

Cette section s’adresse aux développeurs qui préfèrent ne pas utiliser le Gestionnaire des identifiants. Nous incluons l’utilitaire SimpleKeychain, une enveloppe légère sur le trousseau du système, qui peut être utilisé pour stocker les jetons en toute sécurité.

Importez d’abord le module `SimpleKeychain` :

`import SimpleKeychain`

Créez ensuite une instance et stockez les jetons dont vous avez besoin. Dans ce cas, vous stockez 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 { 
                // Handle error 
                return
            }
            // Store the tokens
            do {
                try keychain.set(credentials.accessToken, forKey: "access_token")
                try keychain.set(refreshToken, forKey: "refresh_token")
            } catch {
                // Handle error
            }
            // You might want to route to your app's main flow at this point
        case .failure(let error):
            // Handle error
        }
}
```

Une fois que vous les avez stockés, vous pouvez à tout moment demander une nouvelle instance [Credentials](https://github.com/auth0/Auth0.swift/blob/master/Auth0/Credentials.swift).

### Renouvellement des identifiants utilisateur

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

Auth0
    .authentication()
    .renew(withRefreshToken: refreshToken)
    .start { result in
        switch(result) {
        case .success(let credentials):
            // If you have Refresh Token Rotation enabled, you get a 
            // new refresh token
            // Otherwise you only get a new access token
            guard let refreshToken = credentials.refreshToken else { 
                // Handle error 
                return
            }
            // Store the new tokens
            do {
                try keychain.set(credentials.accessToken, forKey: "access_token")
                try keychain.set(refreshToken, forKey: "refresh_token")
            } catch {
                // Handle error
            }
        case .failure(let error):
            // Handle error
        }
}
```