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 relatives à la communication (XR-015 et XR-045). La bibliothèque d’assistance XBOX Live est disponible sur Nuget.org.

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 d’assistance XBOX Live	PlayFab Party version 1.0.1	PlayFab Party version 1.3.0+
1.0.1	✔
1.1.0	✔
1.2.0		✔
1.2.5		✔

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 et en reflétant cette liste dans la bibliothèque d’assistance XBOX Live via PartyXblManager::CreateLocalChatUser et PartyXblManager::CreateRemoteChatUser. Pour les utilisateurs locaux :

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.

    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. Pour les utilisateurs distants :

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.

    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.

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

    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.

    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.

    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().

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

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

    PartyXblCrossNetworkCommunicationPrivacySetting crossNetworkSetting;
    localChatUser->GetCrossNetworkCommunicationPrivacySetting(&crossNetworkSetting);

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

Vous trouverez ici plus d’informations sur XR-015 et sur son application au jeu et à la communication inter-réseaux

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

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 pour obtenir le même résultat.

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.

    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.

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

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

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

XBOX Services

PlayFab

Bibliothèque d'assistance XBOX Live pour PlayFab Party

Vue d’ensemble de la bibliothèque d’assistance XBOX Live

Compatibilité avec la bibliothèque PlayFab Party

Suivi des utilisateurs XBOX Live

Création de PartyLocalChatControls à partir de PartyXblLocalChatUsers

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

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

Respect des autorisations de communication inter-réseaux

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

Considérations particulières pour Windows

​Vue d’ensemble de la bibliothèque d’assistance XBOX Live

​Compatibilité avec la bibliothèque PlayFab Party

​Suivi des utilisateurs XBOX Live

​Création de PartyLocalChatControls à partir de PartyXblLocalChatUsers

​Respect des préférences d’accessibilité d’un utilisateur XBOX Live

​Respect des paramètres de confidentialité et des autorisations d’un utilisateur XBOX Live

​Respect des autorisations de communication inter-réseaux

​Correspondance entre les ID d’utilisateur XBOX Live et les ID d’entité PlayFab

​Considérations particulières pour Windows

Vue d’ensemble de la bibliothèque d’assistance XBOX Live

Compatibilité avec la bibliothèque PlayFab Party

Suivi des utilisateurs XBOX Live

Création de PartyLocalChatControls à partir de PartyXblLocalChatUsers

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

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

Respect des autorisations de communication inter-réseaux

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

Considérations particulières pour Windows