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

# Gérer l'expiration des jetons

> Gérez l'expiration des jetons d'entité PlayFab, l'actualisation des jetons en arrière-plan et la reconnexion manuelle dans le SDK C, y compris les flux de suspension et de reprise du GDK.

Le SDK PlayFab Services inclut un mécanisme d'actualisation des jetons en arrière-plan qui permet de maintenir la session de votre joueur active. Il est important de comprendre le fonctionnement de ce mécanisme, et de savoir quand votre jeu doit intervenir, en particulier pour les titres Game Development Kit (GDK) qui prennent en charge la suspension et la reprise.

## Fonctionnement de l'actualisation automatique des jetons

Le SDK exécute un processus d'arrière-plan qui vérifie périodiquement le jeton d'entité du joueur. Si le jeton est **toujours valide mais proche de son expiration** (moins d'une heure avant l'expiration), le SDK se réauthentifie automatiquement à l'aide des informations d'identification de l'appel de connexion d'origine. Si cette actualisation réussit, le jeton est mis à jour de manière transparente et le **PFEntityHandle** reste valide. Votre jeu n'a aucune action à effectuer.

Vous pouvez observer ces actualisations silencieuses de jetons en inscrivant un rappel [**PFEntityRegisterTokenRefreshedEventHandler**](/fr/services/playfab/api-references/c/pfentity/functions/pfentityregistertokenrefreshedeventhandler) (voir [Actualisation transparente](#transparent-refresh)).

## Quand votre jeu doit gérer l'expiration des jetons

Dans certains scénarios, le SDK **ne peut pas** actualiser automatiquement le jeton :

* **Le jeton a déjà expiré.** L'actualisation automatique ne fonctionne que si le jeton est encore valide. Si le jeton a complètement expiré, par exemple après un long cycle de suspension/reprise, le SDK ne tente pas de reconnexion automatique. Il en informe plutôt votre jeu via le **TokenExpiredHandler**.
* **Les informations d'identification de connexion d'origine ne sont plus valides.** Si le handle ou le jeton fourni initialement à la requête de connexion n'est plus valide, l'actualisation automatique échoue et le **TokenExpiredHandler** est appelé.

<Info>
  L'inscription d'un [**PFEntityTokenExpiredEventHandler**](/fr/services/playfab/api-references/c/pfentity/functions/pfentitytokenexpiredeventhandler) est recommandée pour tous les titres et est **indispensable** pour les titres GDK qui prennent en charge la suspension et la reprise. Sans ce gestionnaire, votre jeu n'a aucun moyen de se rétablir après l'expiration d'un jeton.
</Info>

### Inscrire le TokenExpiredHandler

Utilisez [**PFEntityRegisterTokenExpiredEventHandler**](/fr/services/playfab/api-references/c/pfentity/functions/pfentityregistertokenexpiredeventhandler) pour vous inscrire à un rappel, et **PFAuthenticationReLoginWith\*Async** pour vous réauthentifier lorsque le jeton expire.

```cpp theme={null}
    PFRegistrationToken registrationTokenExpired{};
    hr = PFEntityRegisterTokenExpiredEventHandler(nullptr, nullptr, [](void* ctx, PFEntityKey const* entityKey)
    {
        PFAuthenticationLoginWithXUserRequest request{};
        request.createAccount = true;
        request.user = user; // An XUserHandle obtained from XUserAddAsync

        XAsyncBlock async{};
        HRESULT hr = PFAuthenticationReLoginWithXUserAsync(GlobalState()->entityHandle, &request, &async); // This assumes the entity handle was stored in the game's global state
        hr = XAsyncGetStatus(&async, true); // This is doing a blocking wait for completion, but you can use the XAsyncBlock to set a callback instead for async style usage

        // After login we could potentially get back a new player entity with a new entity key
        PFEntityKey const* pEntityKey{};
        std::vector<char> entityKeyBuffer;
        size_t size{};
        hr = PFEntityGetEntityKeySize(GlobalState()->entityHandle, &size); // Add your own error handling when FAILED(hr) == true

        entityKeyBuffer.resize(size);
        hr = PFEntityGetEntityKey(GlobalState()->entityHandle, entityKeyBuffer.size(), entityKeyBuffer.data(), &pEntityKey, nullptr);
    }, &registrationTokenExpired);
```

## GDK : suspension, reprise et Quick Resume

Sur les plateformes GDK (consoles XBOX et Windows avec le GDK), un jeu peut être suspendu pendant une période prolongée, par exemple lorsque le joueur passe à un autre jeu, puis revient plus tard via Quick Resume. Pendant la suspension, le jeton d'entité peut expirer. Comme aucun code ne s'exécute pendant la suspension, l'actualisation périodique en arrière-plan du SDK ne peut pas maintenir le jeton actif.

### Ce qui se passe à la reprise

Lorsque votre jeu reprend, le SDK détecte **immédiatement** l'état de reprise et vérifie le jeton d'entité. Il n'attend pas le cycle d'actualisation périodique suivant. Si le jeton a expiré pendant la suspension :

1. Le SDK détecte le jeton expiré.
2. Le rappel **TokenExpiredHandler** est appelé.
3. Votre jeu doit appeler **PFAuthenticationReLoginWith\*Async** depuis le gestionnaire pour obtenir un nouveau jeton.

<Note>
  La vérification du jeton à la reprise est déclenchée dès que la connectivité réseau est rétablie. Si le réseau met un certain temps à se réinitialiser après la reprise, le SDK attend la connectivité avant de vérifier le jeton. Aucune vérification de jeton n'est perdue.
</Note>

<a id="transparent-refresh" />

## Actualisation transparente

Si vous souhaitez que votre jeu sache quand le SDK actualise automatiquement le jeton d'entité du joueur, vous pouvez vous inscrire à un rappel. Ce gestionnaire est appelé lorsque le SDK actualise avec succès un jeton proche de son expiration ; votre jeu n'a aucune action à effectuer.

```cpp theme={null}
    PFRegistrationToken registrationTokenRefreshed{};
    hr = PFEntityRegisterTokenRefreshedEventHandler(nullptr, nullptr, [](void* ctx, PFEntityKey const* entityKey, const PFEntityToken* newToken)
    {
        // Perform any logging or other desired actions on token refresh
    }, &registrationTokenRefreshed);
```

## Désinscrire les gestionnaires

Lors de l'arrêt de PlayFab, ou lorsque vous souhaitez ne plus recevoir les rappels d'expiration et d'actualisation des jetons, appelez la fonction de désinscription appropriée.

```cpp theme={null}
    PFEntityUnregisterTokenExpiredEventHandler(registrationTokenExpired);
    PFEntityUnregisterTokenRefreshedEventHandler(registrationTokenRefreshed);
```

## Référence

[Documentation de référence de l'API](/fr/services/playfab/api-references/c/pfauthentication/pfauthentication_members)


## Related topics

- [Handles d'entité](/fr/services/playfab/sdks/c/entity-handles.md)
- [Gérer les erreurs PlayFab](/fr/services/playfab/sdks/c/errors.md)
- [Démarrage rapide GDK](/fr/services/playfab/sdks/c/quickstart-gdk.md)
- [Authentification des services XBOX](/fr/services/xbox-services/fundamentals/s2s-auth-calls/service-authentication/live-xbox-live-authentication.md)
- [Authentification des services XBOX pour les services de titre](/fr/services/xbox-services/fundamentals/s2s-auth-calls/service-authentication/live-title-service-authentication.md)