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

# Démarrage rapide (Windows) - Appel des services PlayFab

> Utilisez le PFEntityHandle authentifié du SDK unifié PlayFab pour récupérer les clés d'entité et appeler les API des services PlayFab depuis un titre Windows.

Ce guide vous montre comment effectuer des appels d'API de service PlayFab à l'aide du SDK unifié. Vous apprendrez à appeler différents services PlayFab pour gérer les données des joueurs, récupérer des fichiers et interagir avec d'autres fonctionnalités PlayFab.

## Prérequis

Avant de commencer, assurez-vous d'avoir :

* Terminé la [configuration du SDK Core et l'authentification](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-core)
* Un `PFEntityHandle` authentifié issu du processus de connexion
* Votre ID de titre PlayFab et votre configuration de service en place

<Note>
  Ce guide suppose que vous avez déjà initialisé le SDK PlayFab et authentifié un joueur en suivant le [guide de démarrage rapide Core](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-core). Si ce n'est pas le cas, suivez d'abord ce guide.
</Note>

## Ce que vous allez accomplir

À la fin de ce démarrage rapide, vous aurez :

* Récupéré la clé d'entité d'un joueur authentifié
* Effectué votre premier appel d'API de service PlayFab
* Traité la réponse d'un service PlayFab

## Effectuer votre premier appel d'API de service

Après une authentification réussie, vous pouvez effectuer des appels d'API PlayFab à l'aide du `PFEntityHandle` obtenu lors de la connexion. Cet exemple montre comment récupérer les fichiers stockés pour le joueur actuel.

### Étape 1 : obtenir la clé d'entité

Tout d'abord, récupérez la clé d'entité à partir de votre handle d'entité authentifié :

```cpp theme={null}
PFEntityKey const* pEntityKey{};
std::vector<char> entityKeyBuffer;
size_t size{};
HRESULT hr = PFEntityGetEntityKeySize(entityHandle, &size);
if (FAILED(hr))
{
    std::wcerr << L"Failed to get entity key size: 0x" << std::hex << hr << std::endl;
    return hr;
}

entityKeyBuffer.resize(size);
hr = PFEntityGetEntityKey(entityHandle, entityKeyBuffer.size(), 
    entityKeyBuffer.data(), &pEntityKey, nullptr);
if (FAILED(hr))
{
    std::wcerr << L"Failed to get entity key: 0x" << std::hex << hr << std::endl;
    return hr;
}

std::wcout << L"Entity ID: " << pEntityKey->id << std::endl;
```

### Étape 2 : appeler l'API GetFiles

Effectuez maintenant votre premier appel de service PlayFab pour obtenir les fichiers associés au joueur :

```cpp theme={null}
// Prepare the request
XAsyncBlock async{};
PFDataGetFilesRequest requestFiles{};
requestFiles.entity = pEntityKey;  // Use the entity key from above

// Make the async API call
HRESULT hr = PFDataGetFilesAsync(entityHandle, &requestFiles, &async);
if (FAILED(hr))
{
    std::wcerr << L"Failed to start GetFiles request: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Wait for the call to complete
hr = XAsyncGetStatus(&async, true);
if (FAILED(hr))
{
    std::wcerr << L"GetFiles request failed: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Get the result size and allocate buffer
size_t resultSize;
hr = PFDataGetFilesGetResultSize(&async, &resultSize);
if (FAILED(hr))
{
    std::wcerr << L"Failed to get result size: 0x" << std::hex << hr << std::endl;
    return hr;
}

// Retrieve the actual result
std::vector<char> getFilesResultBuffer(resultSize);
PFDataGetFilesResponse* getFilesResponseResult{ nullptr };
hr = PFDataGetFilesGetResult(&async, getFilesResultBuffer.size(), 
    getFilesResultBuffer.data(), &getFilesResponseResult, nullptr);
if (SUCCEEDED(hr))
{
    std::wcout << L"Successfully retrieved files. Count: " 
               << (getFilesResponseResult->metadata ? getFilesResponseResult->metadataCount : 0) 
               << std::endl;
    
    // Process the files as needed
    if (getFilesResponseResult->metadata)
    {
        for (uint32_t i = 0; i < getFilesResponseResult->metadataCount; ++i)
        {
            std::wcout << L"File: " << getFilesResponseResult->metadata[i].fileName << std::endl;
        }
    }
}
else
{
    std::wcerr << L"Failed to get GetFiles result: 0x" << std::hex << hr << std::endl;
}
```

🎉 **Félicitations!** Vous avez effectué avec succès votre premier appel d'API de service PlayFab à l'aide du SDK unifié.

## Comprendre le modèle d'appel d'API

Tous les appels d'API de service PlayFab suivent un modèle similaire :

1. **Préparer la requête** : créez et renseignez une structure de requête
2. **Lancer l'appel asynchrone** : appelez la fonction `*Async`
3. **Attendre la fin** : utilisez `XAsyncGetStatus` pour attendre la fin de l'opération
4. **Obtenir la taille du résultat** : appelez `*GetResultSize` pour déterminer la taille de mémoire tampon nécessaire
5. **Récupérer le résultat** : appelez `*GetResult` pour obtenir les données proprement dites

Ce modèle s'applique à toutes les API de service PlayFab, ce qui facilite l'utilisation des différents services une fois les bases comprises.

## Étapes suivantes

Maintenant que vous avez appelé avec succès un service PlayFab, découvrez ces fonctionnalités supplémentaires :

### API de service courantes

* **Gestion des données des joueurs** : stockez et récupérez des données de joueur personnalisées
* **Statistiques des joueurs** : suivez les statistiques et les succès des joueurs
* **Données de titre** : accédez aux données de configuration du jeu
* **Cloud Script** : exécutez une logique côté serveur

### Fonctionnalités avancées

* **Classements** : implémentez des fonctionnalités compétitives avec des classements
* **Économie et monétisation** : ajoutez des monnaies virtuelles et des objets
* **Multijoueur** : intégrez les services de matchmaking et de lobby
* **Analytique** : suivez le comportement des joueurs et les métriques du jeu

### Pratiques exemplaires

* [Opérations asynchrones](/fr-CA/services/playfab/sdks/unified-sdk/async-model) : comprendre le modèle de programmation asynchrone de PlayFab
* [Gestion de la mémoire](/fr-CA/services/playfab/sdks/unified-sdk/memory-management) : pratiques exemplaires de gestion de la mémoire du SDK
* [Traçage et diagnostics](/fr-CA/services/playfab/sdks/unified-sdk/debug-trace) : déboguer et surveiller votre intégration

## Résolution des problèmes

**Problèmes courants et solutions :**

| Problème | Solution |
| - | - |
| Handle d'entité non valide | Vérifiez que l'authentification s'est terminée avec succès |
| Délai d'expiration de l'appel d'API | Vérifiez la connectivité réseau et l'état du service PlayFab |
| Erreurs d'accès refusé | Vérifiez votre ID de titre et les autorisations de l'entité |
| Erreurs de taille de mémoire tampon | Appelez toujours `*GetResultSize` avant `*GetResult` |

Pour obtenir des informations plus détaillées sur les erreurs, activez le [traçage et les diagnostics](/fr-CA/services/playfab/sdks/unified-sdk/debug-trace) dans votre application.

## Documentation de référence

* [Référence de l'API du SDK unifié PlayFab](/fr-CA/services/playfab/api-references/c/pfauthentication/pfauthentication_members)
* [Référence de l'API PlayFab Services](/fr-CA/services/playfab/api-references)
* [Documentation de l'API PlayFab Data](https://docs.microsoft.com/gaming/playfab/api-references/data/)


## Related topics

- [Démarrage rapide Unity](/fr-CA/services/playfab/sdks/unity3d/quickstart.md)
- [Démarrage rapide Unreal Engine](/fr-CA/services/playfab/sdks/unreal/quickstart.md)
- [Démarrage rapide C++ pour Windows](/fr-CA/services/playfab/sdks/playfab-cpp/quickstart-windows.md)
- [Démarrage rapide (Windows) - Configuration du SDK Core](/fr-CA/services/playfab/sdks/unified-sdk/quickstart-core.md)
- [Démarrage rapide](/fr-CA/services/playfab/economy-monetization/economy-v2/quickstart.md)