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

# Bibliothèque d'assistance XBOX Live pour PlayFab Party

> Utilisez la bibliothèque d'assistance PartyXboxLive pour relier les identités, les autorisations de chat et les paramètres de confidentialité XBOX Live à la voix et à la mise en réseau de PlayFab Party.

# Vue d'ensemble de la bibliothèque d'assistance XBOX Live

La bibliothèque d'assistance XBOX Live pour PlayFab Party est conçue pour aider les jeux qui utilisent PlayFab Party à respecter les [stratégies XBOX Live](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/live/get-started/live-xbl-overview) relatives à la communication (XR-015 et XR-045). La bibliothèque d'assistance XBOX Live est disponible sur [Nuget.org](https://www.nuget.org/profiles/PlayFab).

## Compatibilité avec la bibliothèque PlayFab Party

Bien que nous nous efforcions de limiter les changements incompatibles dans nos API, certaines modifications apportées à l'API PlayFab Party peuvent amener la bibliothèque d'assistance XBOX Live à renvoyer des valeurs erronées. Consultez le tableau ci-dessous pour vous assurer que les versions de vos bibliothèques sont compatibles.

| Version de la bibliothèque <br /> d'assistance XBOX Live | PlayFab Party version <br /> 1.0.1 | PlayFab Party version <br /> 1.3.0+ |
| - | :-: | :-: |
| **1.0.1** | ✔ | |
| **1.1.0** | ✔ | |
| **1.2.0** | | ✔ |
| **1.2.5** | | ✔ |

<a id="keeping-track-of-xbox-live-users" />

## Suivi des utilisateurs XBOX Live

La bibliothèque d'assistance XBOX Live pour PlayFab Party doit être explicitement informée des utilisateurs XBOX Live participant actuellement à la session Party. Il est recommandé que les titres informent la bibliothèque en écoutant les modifications de leur [document de session multijoueur](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/live/get-started/live-xbl-overview) et en reflétant cette liste dans la bibliothèque d'assistance XBOX Live via `PartyXblManager::CreateLocalChatUser` et `PartyXblManager::CreateRemoteChatUser`.

Pour les utilisateurs locaux :

```cpp theme={null}
void
OnLocalXboxUserAddedToMPSD(
    uint64_t xboxUserId
    )
{
    PartyXblLocalChatUser* localChatUser;
    PartyError err = PartyXblManager::GetSingleton().CreateLocalChatUser(xboxUserId, nullptr, &localChatUser);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("CreateLocalChatUser failed: %s\n", PartyXblManager::GetErrorMessage(err));
        return;
    }
}
```

À ce stade, si un PartyLocalChatControl existe déjà pour l'utilisateur XBOX local correspondant, vous pouvez l'associer à ce PartyXblLocalChatUser via les méthodes SetCustomContext.

```cpp theme={null}
    localChatControl->SetCustomContext(localChatUser);
    localChatUser->SetCustomContext(localChatControl);
```

Sinon, vous pouvez utiliser ce nouveau PartyXblLocalChatUser pour générer le contrôle de chat et les associer à ce moment-là. Pour plus d'informations, consultez [Création de PartyLocalChatControls à partir de PartyXblLocalChatUsers](#creating-partylocalchatcontrols-from-partyxbllocalchatusers).

Pour les utilisateurs distants :

```cpp theme={null}
void
OnRemoteXboxUserAddedToMPSD(
    uint64_t xboxUserId
    )
{
    PartyXblChatUser* remoteChatUser;
    PartyError err = PartyXblManager::GetSingleton().CreateRemoteChatUser(remoteXboxUserId, &remoteChatUser);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("CreateRemoteChatUser failed: %s\n", PartyXblManager::GetErrorMessage(err));
        return;
    }
```

À ce stade, si un PartyChatControl existe déjà pour l'utilisateur XBOX distant correspondant, vous pouvez l'associer à ce PartyXblChatUser via les méthodes SetCustomContext.

```cpp theme={null}
    remoteChatControl->SetCustomContext(remoteChatUser);
    remoteChatUser->SetCustomContext(remoteChatControl);
```

Gardez à l'esprit que les mises à jour du document de session et les mises à jour de la liste des contrôles de chat distants peuvent ne pas être ordonnées, et qu'une logique d'association similaire peut être nécessaire lors du traitement des mises à jour `PartyChatControlCreatedStateChange` pour les contrôles de chat distants.

Pour les utilisateurs de chat locaux comme distants, il est important de garder à l'esprit que la bibliothèque Party principale identifie les utilisateurs et les contrôles de chat via des ID d'entité PlayFab, tandis que la bibliothèque d'assistance XBOX Live identifie les utilisateurs de chat avec des ID d'utilisateur XBOX. Il est donc souvent nécessaire de convertir les uns en les autres. Pour plus d'informations, consultez [Correspondance entre les ID d'utilisateur XBOX Live et les ID d'entité PlayFab](#mapping-between-xbox-live-user-ids-and-playfab-entity-ids).

<a id="creating-partylocalchatcontrols-from-partyxbllocalchatusers" />

## Création de PartyLocalChatControls à partir de PartyXblLocalChatUsers

Les objets `PartyXblLocalChatUser` ne sont souvent utiles que lorsqu'ils sont associés à des objets `PartyLocalUser` et `PartyLocalChatControl` de la bibliothèque Party. La génération d'objets `PartyLocalUser` et `PartyLocalChatControl` nécessite que les titres connectent leurs utilisateurs à PlayFab et récupèrent l'`entityId` et le `titlePlayerEntityToken` de leurs utilisateurs. La connexion peut être effectuée via le [SDK PlayFab CPP](/fr/services/playfab/sdks/playfab-cpp), mais si un titre prévoit d'utiliser les informations d'identification XBOX Live pour se connecter à PlayFab, il peut utiliser `PartyXblManager::LoginToPlayFab` pour éviter d'ajouter une dépendance supplémentaire.

L'exemple suivant montre comment la bibliothèque d'assistance XBOX Live peut vous aider à créer des objets `PartyLocalUser` et `PartyLocalChatControl` à partir d'objets `PartyXblLocalChatUser`. Pour plus d'informations sur la création d'objets `PartyXblLocalChatUser`, consultez [Suivi des utilisateurs XBOX Live](#keeping-track-of-xbox-live-users).

```cpp theme={null}
    err = PartyXblManager::GetSingleton().LoginToPlayFab(localChatUser, nullptr);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("LoginToPlayFab failed: %s\n", PartyXblManager::GetErrorMessage(err));
        return;
    }
```

Peu après l'appel de `PartyXblManager::LoginToPlayFab`, vous recevez un `PartyXblLoginToPlayFabCompletedStateChange` contenant le résultat de l'opération de connexion.

```cpp theme={null}
    PartyLocalUser* partyLocalUser;
    if (stateChange->stateChangeType == PartyXblStateChangeType::LoginToPlayFabCompleted)
    {
        auto loginToPlayFabCompleted = static_cast<PartyXblLoginToPlayFabCompletedStateChange*>(stateChange);
        if (loginToPlayFabCompleted->result == PartyXblStateChangeResult::Succeeded)
        {
            err = PartyManager::GetSingleton().CreateLocalUser(
                loginToPlayFabCompleted->entityId,
                loginToPlayFabCompleted->titlePlayerEntityToken,
                partyLocalUser));
            if (PARTY_FAILED(err))
            {
                DEBUGLOG("CreateLocalUser failed: %s\n", PartyManager::GetErrorMessage(err));
                return;
            }
        }
    }

    PartyLocalDevice* localDevice;
    err = PartyManager::GetSingleton().GetLocalDevice(&localDevice);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("GetLocalDevice failed: %s\n", PartyManager::GetErrorMessage(err));
        return;
    }

    PartyLocalChatControl* localChatControl;
    err = localDevice->CreateChatControl(partyLocalUser, nullptr, nullptr, &localChatControl);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("CreateChatControl failed: %s\n", PartyManager::GetErrorMessage(err));
        return;
    }

    // We can use the custom context on the PartyXblLocalChatUser to store the PartyLocalChatControl for easy access
    // in the future.
    localChatUser->SetCustomContext(localChatControl);
```

## Respect des préférences d'accessibilité d'un utilisateur XBOX Live

L'objet `PartyXblLocalChatUser` expose certaines des préférences d'accessibilité de l'utilisateur XBOX Live qui sont pertinentes pour les sessions de chat Party. Les titres peuvent utiliser ces informations pour offrir une meilleure expérience à leurs joueurs en activant immédiatement certaines des fonctionnalités d'accessibilité de Party.

```cpp theme={null}
    PartyXblAccessibilitySettings accessibilitySettings;
    err = localChatUser->GetAccessibilitySettings(&accessibilitySettings);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("GetAccessibilitySettings failed: %s\n", PartyXblManager::GetErrorMessage(err));
        return;
    }

    if (accessibilitySettings.speechToTextEnabled)
    {
        PartyVoiceChatTranscriptionOptions option = PartyVoiceChatTranscriptionOptions::TranscribeOtherChatControlsWithMatchingLanguages;
        m_localChatControl->SetTranscriptionOptions(option, nullptr);
    }
```

## Respect des paramètres de confidentialité et des autorisations d'un utilisateur XBOX Live

Selon les stratégies XBOX Live, les titres ne doivent pas autoriser la communication via XBOX Live lorsque les paramètres de confidentialité ou les autorisations de l'utilisateur ne le permettent pas. La bibliothèque d'assistance XBOX Live vous aide à y parvenir en vous permettant d'interroger les `PartyChatPermissionOptions` les plus restrictives autorisées par les stratégies XBOX Live entre deux utilisateurs. Chaque fois que cette valeur change, un `PartyXblRequiredChatPermissionInfoChangedStateChange` est généré par la bibliothèque. Les `PartyChatPermissionOptions` mises à jour peuvent être obtenues en appelant `PartyXblLocalChatUser::GetRequiredChatPermissionInfo()`.

```cpp theme={null}
    PartyXblChatUser* remoteChatUser;
    PartyError err = PartyXblManager::GetSingleton().CreateRemoteChatUser(remoteXboxUserId, &remoteChatUser);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("CreateRemoteChatUser failed: %s\n", PartyXblManager::GetErrorMessage(err));
        return;
    }

    // Once the chat control representing this remote Xbox Live user joins a network, we can use the custom context
    // on the PartyXblChatUser to store the chat control object for quick access in the future.
    remoteChatUser->SetCustomContext(m_remotePartyChatControl);
```

La bibliothèque d'assistance XBOX Live suit les paramètres de confidentialité et de privilèges de chaque utilisateur de chat distant par rapport à chaque utilisateur de chat local en communiquant avec les services de confidentialité XBOX Live. En outre, la bibliothèque écoute les modifications de ces paramètres en s'abonnant aux mises à jour [Real-Time Activity](/fr/services/xbox-services/fundamentals/rta/live-rta-nav). Lorsque de nouveaux utilisateurs de chat distants sont ajoutés, ou lorsque la relation de confidentialité et de privilèges entre un utilisateur de chat local et un utilisateur de chat distant existant change, un `PartyXblRequiredChatPermissionInfoChangedStateChange` est généré pour vous informer qu'une valeur `PartyChatPermissionOptions` mise à jour est désormais disponible.

```cpp theme={null}
    // Wait for PartyXblRequiredChatPermissionInfoChangedStateChange
    if (stateChange->stateChangeType == PartyXblStateChangeType::RequiredChatPermissionInfoChanged)
    {
        auto chatPermissionChanged = static_cast<PartyXblRequiredChatPermissionInfoChangedStateChange*>(stateChange);

        PartyXblLocalChatUser* localChatUser = chatPermissionChanged->localChatUser;
        PartyXblChatUser* targetChatUser = chatPermissionChanged->targetChatUser;

        PartyXblChatPermissionInfo chatPermissionInfo;
        PartyError err = localChatUser->GetRequiredChatPermissionInfo(targetChatUser, &chatPermissionInfo);
        if (PARTY_FAILED(err))
        {
            DEBUGLOG("GetRequiredChatPermissionInfo failed: %s\n", PartyXblManager::GetErrorMessage(err));
            return;
        }

        PartyLocalChatControl* localChatControl;
        localChatUser->GetCustomContext(reinterpret_cast<void**>(&localChatControl));
        if (PARTY_FAILED(err))
        {
            DEBUGLOG("GetCustomContext failed: %s\n", PartyXblManager::GetErrorMessage(err));
            return;
        }

        PartyChatControl* targetChatControl;
        targetChatUser->GetCustomContext(reinterpret_cast<void**>(&targetChatControl));
        if (PARTY_FAILED(err))
        {
            DEBUGLOG("GetCustomContext failed: %s\n", PartyXblManager::GetErrorMessage(err));
            return;
        }

        localChatControl->SetPermission(targetChatControl, chatPermissionInfo.chatPermissionMask);
        if (PARTY_FAILED(err))
        {
            DEBUGLOG("SetPermission failed: %s\n", PartyXblManager::GetErrorMessage(err));
            return;
        }
    }
```

La structure `PartyXblChatPermissionInfo` contient deux informations :

* Un masque `PartyChatPermissionOptions` qui peut être soit transmis tel quel à `PartyLocalChatControl::SetPermission()`, soit utilisé comme masque binaire si vous disposez déjà d'une valeur `PartyChatPermissionOptions` que vous souhaitez utiliser tout en vous assurant de respecter les stratégies XBOX Live.
* Une valeur `PartyXblChatPermissionMaskReason` qui fournit des informations supplémentaires sur la valeur de `PartyXblChatPermissionInfo::chatPermissionMask`

| **PartyXblChatPermissionMaskReason** | **Explication** |
| :- | :- |
| NoRestriction | Aucune restriction ne s'applique actuellement à cette autorisation de chat. |
| Determining | La communication est restreinte pendant que le privilège de communication et les paramètres de confidentialité de l'utilisateur local sont en cours de détermination |
| Privilege | La communication est restreinte en raison du privilège de communication de l'utilisateur local. |
| Privacy | La communication est restreinte en raison des paramètres de confidentialité de l'utilisateur local vis-à-vis de l'utilisateur de chat cible. |
| InvalidTargetUser | La communication est restreinte, car l'utilisateur cible n'a pas été reconnu comme valide par les services XBOX Live. |
| XboxLiveServiceError | L'autorisation de chat requise n'a pas pu être déterminée en raison de problèmes liés aux services XBOX Live. |
| UnknownError | L'autorisation de chat requise n'a pas pu être déterminée en raison d'une erreur interne inconnue. |

## Respect des autorisations de communication inter-réseaux

Les titres qui prennent en charge le jeu et la communication inter-réseaux entre joueurs XBOX Live et joueurs non XBOX Live doivent vérifier les autorisations de communication avant d'autoriser la communication entre ces joueurs. La bibliothèque d'assistance XBOX Live fournit ces informations via `PartyXblLocalChatUser::GetCrossNetworkCommunicationPrivacySetting()`. Cette méthode renvoie une énumération `PartyXblCrossNetworkCommunicationPrivacySetting` avec trois valeurs possibles :

| **PartyXblCrossNetworkCommunicationPrivacySetting** | **Explication** |
| :- | :- |
| Allowed | Les autorisations de cet utilisateur XBOX Live sont définies pour autoriser la communication avec tous les joueurs d'autres réseaux. |
| FriendsOnly | Les autorisations de cet utilisateur XBOX Live sont définies pour autoriser la communication uniquement avec ses amis d'autres réseaux. |
| Disallowed | Les autorisations de cet utilisateur XBOX Live n'autorisent aucune communication avec les joueurs d'autres réseaux. |

```cpp theme={null}
    PartyXblCrossNetworkCommunicationPrivacySetting crossNetworkSetting;
    localChatUser->GetCrossNetworkCommunicationPrivacySetting(&crossNetworkSetting);

    if (crossNetworkSetting == PartyXblCrossNetworkCommunicationPrivacySetting::Disallowed)
    {
        m_localChatControl->SetPermissions(crossNetworkChatControl, PartyChatPermissionOptions::None);
    }
```

Vous trouverez [ici](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/live/get-started/live-xbl-overview) plus d'informations sur XR-015 et sur son application au jeu et à la communication inter-réseaux

<a id="mapping-between-xbox-live-user-ids-and-playfab-entity-ids" />

## Correspondance entre les ID d'utilisateur XBOX Live et les ID d'entité PlayFab

De nombreux titres XBOX Live utilisant PlayFab Party doivent convertir les ID d'utilisateur XBOX Live (utilisés dans tout l'écosystème XBOX Live) en ID d'entité PlayFab (utilisés par PlayFab Party), et inversement. À l'aide de `PartyXblManager::GetEntityIdsFromXboxLiveUserIds`, les titres peuvent récupérer une liste d'ID d'entité PlayFab correspondant à une liste donnée d'ID d'utilisateur XBOX Live. Les titres sont censés disposer déjà d'une liste d'ID d'utilisateur XBOX Live grâce à un service de liste externe, comme le [Multiplayer Session Directory](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/live/get-started/live-xbl-overview). En associant les ID d'utilisateur XBOX Live de la liste à leurs ID d'entité PlayFab, nous pouvons construire une correspondance de tous les ID d'entité PlayFab correspondant à la liste de votre session de jeu. Cette correspondance peut ensuite être utilisée pour associer les objets `PartyEndpoint` et `PartyChatControl` aux utilisateurs XBOX Live correspondants.

<Note>
  Chaque ID d'utilisateur XBOX Live ne correspond à un ID d'entité PlayFab que si cet utilisateur XBOX Live a déjà été lié à un compte PlayFab. Un compte PlayFab est automatiquement créé et lié la première fois que `PartyXblManager::LoginToPlayFab` est appelé pour un utilisateur XBOX donné. Les utilisateurs du SDK PlayFab peuvent également utiliser l'API [LoginWithXbox](https://learn.microsoft.com/en-us/rest/api/playfab/client/authentication/login-with-xbox?view=playfab-rest\&preserve-view=true) pour obtenir le même résultat.
</Note>

Le `PartyXblLocalChatUser` local est utilisé pour s'authentifier auprès de PlayFab. Si l'utilisateur ne s'est pas connecté auparavant à PlayFab par un appel à `PartyXblManager::LoginToPlayFab`, la bibliothèque d'assistance XBOX Live doit authentifier l'utilisateur en arrière-plan.

```cpp theme={null}
    uint32_t userCount;
    PartyXblChatUserArray chatUsers;
    PartyError err = PartyXblManager::GetSingleton().GetChatUsers(&userCount, &users);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("GetChatUsers failed: %s\n", PartyXblManager::GetErrorMessage(err));
        return;
    }

    // The list of remote Xbox Live User IDs. This can be populated with arbitrary IDs
    // std::vector<uint64_t> remoteXboxLiveUserIds = {2533274792693551, 2814659110958830};
    //
    // but can also be pulled from the list of remote chat users
    std::vector<uint64_t> remoteXboxLiveUserIds;
    for (uint32_t i = 0; i < userCount; ++i)
    {
        PartyXblChatUser* chatUser = users[i];

        PartyXblLocalChatUser* localChatUser;
        err = chatUser->GetLocal(&localChatUser);
        if (PARTY_FAILED(err))
        {
            DEBUGLOG("PartyChatUser(0x%p)::GetLocal failed: %s\n", chatUser, PartyXblManager::GetErrorMessage(err));
            return;
        }

        if (localChatUser != nullptr)
        {
            continue; // ignore local users
        }

        uint64_t userId;
        err = chatUser->GetXboxUserId(&userId);
        if (PARTY_FAILED(err))
        {
            DEBUGLOG("PartyChatUser(0x%p)::GetXboxUserId failed: %s\n", chatUser, PartyXblManager::GetErrorMessage(err));
            return;
        }

        remoteXboxLiveUserIds.push_back(userId);
    }

    err = PartyXblManager::GetSingleton().GetEntityIdsFromXboxLiveUserIds(
        remoteXboxLiveUserIds.size(),
        remoteXboxLiveUserIds.data(),
        localChatUser,
        nullptr);
    if (PARTY_FAILED(err))
    {
        DEBUGLOG("GetEntityIdsFromXboxLiveUserIds failed: %s\n", PartyXblManager::GetErrorMessage(err));
        return;
    }
```

Peu après l'appel de `PartyXblManager::GetEntityIdsFromXboxLiveUserIds`, vous recevez un `PartyXblGetEntityIdsFromXboxLiveUserIdsCompletedStateChange` contenant le résultat de l'opération. Ce résultat peut être utilisé pour construire ou mettre à jour vos correspondances.

```cpp theme={null}
    // Wait for PartyXblGetEntityIdsFromXboxLiveUserIdsCompletedStateChange
    if (stateChange->stateChangeType == PartyXblStateChangeType::GetEntityIdsFromXboxLiveUserIdsCompleted)
    {
        std::vector<std::pair<uint64_t, std::string>> cachedXboxUserIdToPlayFabEntityIdMap;

        auto getEntityIdsFromXboxLiveUserIdsResult = static_cast<PartyXblGetEntityIdsFromXboxLiveUserIdsCompletedStateChange*>(stateChange);
        for (uint32_t i = 0; i < getEntityIdsFromXboxLiveUserIdsResult.entityIdMappingCount; ++i)
        {
            const PartyXblXboxUserIdToPlayFabEntityIdMapping& idMapping = getEntityIdsFromXboxLiveUserIdsResult.entityIdMappings[i];

            Log("   Xbox Live User ID: %llu", idMapping.xboxLiveUserId);
            if (strlen(idMapping.playfabEntityId)) != 0)
            {
                Log("    PlayFab Entity ID: %s", idMapping.playfabEntityId);
                cachedXboxUserIdToPlayFabEntityIdMap.emplace_back(idMapping.xboxLiveUserId, idMapping.playfabEntityId);
            }
            else
            {
                // This Xbox Live User did not have a linked PlayFab Account.
                Log("    PlayFab Entity ID: NOT FOUND");
            }
        }

        m_cachedXboxUserIdToPlayFabEntityIdMap = std::move(cachedXboxUserIdToPlayFabEntityIdMap);
```

Grâce à une telle correspondance, les titres peuvent reconnaître lorsqu'un objet Party représente un utilisateur XBOX Live.

```cpp theme={null}
uint64_t
GetXboxUserIdFromPlayFabEntityId(
    PartyString entityId
    )
{
    for (const std::pair<uint64_t, std::string>& idMapping : m_cachedXboxUserIdToPlayFabEntityIdMap)
    {
        const std::string& entityIdForXboxUserId = idMapping.second;
        if (entityIdForXboxUserId == entityId)
        {
            return idMapping.first;
        }
    }

    // Failed to find a matching Xbox User ID. This Entity ID does not represent an Xbox Live user.
    return 0;
}
```

## Considérations particulières pour Windows

Sous Windows, la bibliothèque d'assistance XBOX Live a besoin de l'aide du titre pour obtenir des jetons XBOX Live. La bibliothèque demande des jetons en générant un `PartyXblTokenAndSignatureRequestedStateChange`. Le titre peut utiliser la [XBOX Authentication Library](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/live/get-started/live-xbl-overview) (XAL) pour répondre à ces demandes. Confier ce travail au titre garantit qu'il conserve le contrôle total de toute gestion de l'interface utilisateur et de toute demande de consentement normalement associée à l'authentification des utilisateurs.

```cpp theme={null}
    if (stateChange->stateChangeType == PartyXblStateChangeType::TokenAndSignatureRequested)
    {
        auto tokenAndSignatureRequested = static_cast<PartyXblTokenAndSignatureRequestedStateChange*>(stateChange);

        // Convert the headers to the format XAL expect
        std::vector<XalHttpHeader> xalHeaders;
        for (uint32_t i = 0; i < stateChange.headerCount; ++i)
        {
            xalHeaders.push_back({stateChange.headers[i].name, stateChange.headers[i].value});
        }

        XalUserGetTokenAndSignatureArgs args = {};
        args.method = stateChange.method;
        args.url = stateChange.url;
        args.headerCount = static_cast<uint32_t>(xalHeaders.size());
        args.headers = xalHeaders.data();
        args.bodySize = stateChange.bodySize;
        args.body = static_cast<const uint8_t*>(stateChange.body);
        args.forceRefresh = stateChange.forceRefresh != 0;
        args.allUsers = stateChange.allUsers != 0;

        XAsyncBlock* asyncBlock = new XAsyncBlock;
        asyncBlock->queue = m_queue;
        HRESULT hr = XalUserGetTokenAndSignatureSilentlyAsync(m_userHandle, &args, asyncBlock);
    }
```

Pour plus de conseils sur la façon de récupérer un jeton et une signature à l'aide de XAL, consultez la [documentation de la XBOX Authentication Library.](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/live/get-started/live-xbl-overview)

Une fois que vous disposez du jeton et de la signature, vous pouvez les fournir à la bibliothèque d'assistance XBOX Live en appelant `PartyXblManager::CompleteGetTokenAndSignatureRequest()` avec le même `correlationId` que celui fourni au titre via le changement d'état.


## Related topics

- [Notes de version de l'assistance XBOX Live pour PlayFab Party](/fr/services/playfab/multiplayer/networking/party-xboxlive-relnotes.md)
- [Intégration de PlayFab pour les titres utilisant les services XBOX](/fr/services/xbox-services/playfab-integration.md)
- [Exigences XBOX](/fr/services/playfab/multiplayer/networking/xbox-requirements.md)
- [PlayFab Party XBOX Live Helper Typedefs](/fr/services/playfab/multiplayer/networking/xblreference/xbltypedefs.md)
- [PlayFab Party XBOX Live Helper Error Codes](/fr/services/playfab/multiplayer/networking/xblreference/partyxblerrors.md)