> ## 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. # Guide d'implémentation de PlayFab Game Saves sur Steam Deck > Guide complet d'implémentation de PlayFab Game Saves sur Steam Deck avec le GDK d'octobre 2025, couvrant l'authentification, les rappels d'interface utilisateur et les stratégies de synchronisation Ce guide couvre spécifiquement les exigences d'implémentation de PlayFab Game Saves sur Steam Deck avec le GDK d'octobre 2025. Avant d'implémenter la prise en charge du Steam Deck, assurez-vous d'avoir rempli les exigences de base de l'[implémentation avec le GDK d'octobre 2025](/fr-CA/services/playfab/player-progression/game-saves/october-2025-gdk-changes). ## Vue d'ensemble L'intégration de Game Saves sur Steam Deck peut être implémentée avec différents niveaux de complexité selon vos exigences multiplateformes. Vous pouvez choisir entre une approche simplifiée limitée à Steam et une intégration complète à l'écosystème XBOX avec des flux d'authentification plus complexes. **Différence critique - comportement de synchronisation** : sous Windows, Game Saves peut s'exécuter entièrement hors processus et poursuivre la synchronisation au-delà de la durée de vie du jeu. Sur Steam Deck, Game Saves s'exécute uniquement dans le processus. Cela signifie que la synchronisation des sauvegardes s'arrête à l'arrêt du jeu, ce qui oblige les jeux à adopter des synchronisations fréquentes pour éviter de perdre une progression non synchronisée. **Bonne pratique pour toutes les plateformes** : bien que ces modèles de synchronisation soient requis pour le Steam Deck, ils sont fortement recommandés pour toutes les plateformes, en particulier les appareils portables ou tout scénario dans lequel des arrêts soudains peuvent se produire (batterie épuisée, plantage du système, fermeture forcée). ## Différences de comportement du moteur de synchronisation | Plateforme | Mode de synchronisation | Synchronisation après l'arrêt | Modèle recommandé | | - | - | - | - | | **PC Windows** | Hors processus | ✅ Se poursuit après l'arrêt du jeu | Synchronisation fréquente recommandée pour la fiabilité | | **Steam Deck** | Dans le processus | ❌ S'arrête à l'arrêt du jeu | **Synchronisation fréquente requise** | **Recommandations générales de synchronisation** (utiles pour toutes les plateformes) : * Synchronisez fréquemment les données de sauvegarde (par exemple, après chaque niveau, point de contrôle ou progression importante) * Synchronisez toujours avant d'afficher une confirmation de « quitter le jeu » * Envisagez une synchronisation en arrière-plan lors des transitions de jeu * Implémentez des indicateurs de progression de la synchronisation pour garantir qu'elle se termine avant l'arrêt * C'est particulièrement important pour les appareils portables, sur lesquels l'épuisement de la batterie ou les arrêts soudains sont fréquents ## Prérequis Avant d'implémenter la prise en charge du Steam Deck, assurez-vous : 1. **D'avoir terminé la configuration du GDK d'octobre 2025** : suivez le [guide d'implémentation avec le GDK d'octobre 2025](/fr-CA/services/playfab/player-progression/game-saves/october-2025-gdk-changes) 2. **D'avoir intégré l'API Steam** : initialisation de base de l'API Steam et détection du Steam Deck 3. **D'avoir choisi une approche d'intégration** : choisissez entre l'intégration à l'écosystème XBOX et l'intégration d'une identité personnalisée (voir ci-dessous) 4. **De disposer de toutes les DLL requises** : les DLL du SDK unifié doivent être déployées avec votre build Steam ## Approches d'implémentation Le Steam Deck offre deux approches d'implémentation, avec des niveaux de complexité et des capacités multiplateformes différents. PlayFab Game Saves est utile pour la synchronisation multiplateforme des sauvegardes au-delà de l'écosystème Steam : vous aurez besoin soit de l'intégration XBOX Live (approche 1), soit de votre propre système d'identité de joueur personnalisé (approche 2). ### Approche 1 : intégration à l'écosystème XBOX (recommandée) **Avantages** : * **Synchronisation multiplateforme complète** : les données de sauvegarde se synchronisent entre le Steam Deck, les consoles XBOX, le PC Microsoft Store et les autres plateformes compatibles XBOX * **Intégration XBOX Live** : les joueurs utilisent leur gamertag XBOX et peuvent accéder aux fonctionnalités sociales XBOX * **Identité de joueur unifiée** : le même profil de joueur sur toutes les plateformes * **Authentification éprouvée** : tire parti de l'infrastructure d'authentification mature de XBOX Live * **Compatibilité XBOX Game Studios** : intégration transparente pour les studios first-party et partenaires XBOX **Complexité** : * **Authentification complexe** : des gestionnaires d'événements XUser et des rappels d'interface utilisateur personnalisés sont requis * **Configuration d'un bac à sable de développement** : requise pour les environnements de test autres que de production * **Privilèges d'administrateur** : requis pour les modifications du Registre lors de la configuration du bac à sable * **Implémentation d'une interface utilisateur supplémentaire** : authentification par code QR et boîtes de dialogue de sélection du gamertag **Quand la choisir** : jeux qui ciblent plusieurs plateformes, y compris les consoles XBOX, titres XBOX Game Studios ou jeux nécessitant une intégration complète à l'écosystème XBOX Live. ### Approche 2 : implémentation d'une identité personnalisée (alternative) **Avantages** : * **Complexité de connexion potentiellement réduite** : aucune authentification d'utilisateur XBOX requise * **Aucune configuration du Registre** : aucune configuration de bac à sable nécessaire * **Aucune API XUser** : élimine les gestionnaires d'événements complexes * **Flexibilité de l'identité personnalisée** : implémentez votre propre système d'identité de joueur multiplateforme **Complexité** : * **Gestion manuelle des joueurs** : vous devez implémenter votre propre système d'identité de joueur multiplateforme * **Intégration limitée à l'écosystème** : aucun accès aux fonctionnalités sociales XBOX Live ni à la base de joueurs XBOX existante * **Passerelles entre plateformes** : nécessite des solutions personnalisées pour relier les joueurs des différentes plateformes * **Infrastructure d'identité supplémentaire** : vous devez créer ou intégrer des systèmes d'identité tiers **Quand la choisir** : jeux centrés sur Steam, jeux disposant déjà de systèmes d'identité personnalisés ou scénarios de développement dans lesquels l'intégration XBOX Live n'est ni nécessaire ni souhaitée. **OpenID Connect** : pour l'approche 2, PlayFab prend en charge l'authentification OpenID Connect au moyen de l'appel d'API `LoginWithOpenIdConnect`, ce qui permet l'intégration avec des fournisseurs d'identité personnalisés prenant en charge la norme OpenID Connect. ## Configuration commune (les deux approches) Les étapes de configuration suivantes sont requises quelle que soit l'approche d'implémentation choisie. ## 1. Exigences de déploiement des DLL Le Steam Deck exige que toutes les DLL du SDK unifié soient déployées avec votre jeu : **DLL requises** : * `libHttpClient.dll` : opérations HTTP * `PlayFabCore.dll` : authentification et services principaux * `PlayFabGameSave.dll` : fonctionnalités de Game Saves * `xgameruntime.dll` : fonctionnalités principales du SDK et connexion XBOX **DLL facultative** : * `PlayFabServices.dll` : services PlayFab supplémentaires (recommandée) **Structure de déploiement sur Steam Deck** : ``` YourGame/ ├── YourGame.exe ├── libHttpClient.dll // Required for HTTP operations ├── PlayFabCore.dll // Required for authentication ├── PlayFabServices.dll // Optional: For additional PlayFab services ├── PlayFabGameSave.dll // Required for Game Saves ├── xgameruntime.dll // Required for Xbox Live services ├── Steam_api64.dll └── Other game files... ``` ## 2. Prérequis de l'intégration Steam ### Intégration de l'API Steam ```cpp theme={null} // Initialize Steam API bool steamAvailable = SteamAPI_Init(); ``` ### Détection de la plateforme Implémentez la détection de la plateforme au début de votre initialisation : ```cpp theme={null} bool DetectSteamDeck() { if (!SteamAPI_Init()) { return false; } return SteamUtils()->IsSteamRunningOnSteamDeck(); } ``` ## 3. Implémentation des rappels d'interface utilisateur **Exigence d'interface utilisateur sur Steam Deck** : tous les rappels d'interface utilisateur de PlayFab Game Saves sont **requis** sur Steam Deck, quelle que soit l'approche d'implémentation choisie. En effet, le Steam Deck ne dispose d'aucune interface utilisateur intégrée pour les opérations de Game Saves; votre application doit donc fournir toutes les boîtes de dialogue. ### Rappels d'interface utilisateur de Game Saves (requis pour les deux approches) Les implémentations avec identité personnalisée et avec l'écosystème XBOX nécessitent les mêmes rappels d'interface utilisateur de PlayFab Game Saves : ```cpp theme={null} // Required Game Saves UI callbacks for Steam Deck (both approaches) PFGameSaveUICallbacks callbacks{}; callbacks.progressCallback = OnPFGameSaveFilesUiProgress; // Sync progress callbacks.syncFailedCallback = OnPFGameSaveFilesUiSyncFailed; // Sync errors callbacks.activeDeviceContentionCallback = OnPFGameSaveFilesUiActiveDeviceContention; // Device conflicts callbacks.conflictCallback = OnPFGameSaveFilesUiConflict; // Save conflicts callbacks.outOfStorageCallback = OnPFGameSaveFilesUiOutOfStorage; // Storage quota HRESULT hr = PFGameSaveFilesSetUiCallbacks(&callbacks); if (FAILED(hr)) { // Handle callback setup failure } // Optional: Additional active device changed callback hr = PFGameSaveFilesSetActiveDeviceChangedCallback(&OnActiveDeviceChanged, nullptr); ``` **Boîtes de dialogue requises pour Game Saves** (les deux approches) : * **Boîtes de dialogue de progression** : affichent la progression de la synchronisation pendant les opérations de sauvegarde * **Gestion des erreurs** : affiche les messages d'échec de synchronisation et les options de nouvelle tentative * **Résolution des conflits** : gère les conflits de sauvegarde entre appareils * **Contention entre appareils** : gère les scénarios d'accès depuis plusieurs appareils * **Gestion de le stockage** : informe les utilisateurs des problèmes de quota de stockage *** ## Approche 1 : intégration à l'écosystème XBOX - implémentation complète Cette approche offre une synchronisation multiplateforme complète entre le Steam Deck, les consoles XBOX, le PC Microsoft Store et les autres plateformes compatibles XBOX. Choisissez cette approche si votre jeu cible les plateformes XBOX ou nécessite une intégration XBOX Live. ### Vue d'ensemble **Prérequis** : * Avoir terminé la configuration commune (sections 1 à 3 ci-dessus) * Disposer d'un accès à un bac à sable de développement pour les tests * Disposer de privilèges d'administrateur pour la configuration du Registre (développement/test uniquement) ### 1. Configuration du Registre Le Steam Deck nécessite une configuration du bac à sable XBOX Live pour les tests dans des bacs à sable autres que de production : ```cpp theme={null} // Set sandbox before Xbox Live services initialization // Only required when testing with non-retail sandboxes if (isSteamDeck) { HRESULT hr = SteamIntegration::SetSandboxForSteamDeck("XDKS.1"); if (FAILED(hr)) { // Handle sandbox setup failure - requires admin privileges return hr; } } ``` **Détails de la configuration** : * **Clé** : `HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\XboxLive\Sandbox` * **Valeur** : ID du bac à sable de développement (par exemple, "XDKS.1") * **Moment** : doit être défini avant l'initialisation des services XBOX Live * **Privilèges** : nécessite un accès administrateur * **Utilisation** : requise uniquement pour les tests dans des bacs à sable autres que de production (environnements de développement/test) ### 2. Gestionnaires d'événements de plateforme XUser Le Steam Deck nécessite deux ensembles critiques de gestionnaires d'événements pour l'authentification XBOX : #### A. Gestionnaires d'événements Remote Connect Ils gèrent le flux d'authentification à distance (affichage du code QR/de l'URL) : ```cpp theme={null} // Handle remote authentication flow (QR code/URL) XUserPlatformRemoteConnectEventHandlers remoteConnect{}; remoteConnect.context = nullptr; remoteConnect.show = &OnRemoteConnectShow; // Display QR code/URL dialog remoteConnect.close = &OnRemoteConnectClose; // Close authentication dialog HRESULT hr = XUserPlatformRemoteConnectSetEventHandlers(nullptr, &remoteConnect); if (FAILED(hr)) { // Handle event handler setup failure } ``` #### B. Gestionnaires d'événements SPOP (invite de connexion) Ils gèrent l'invite de connexion SPOP utilisée lorsque le compte d'un utilisateur est déjà connecté sur un autre appareil : ```cpp theme={null} // Handle SPOP sign-in prompt. See sample: ShowSpopPromptDialogForXUserOnSteamDeck HRESULT hr = XUserPlatformSpopPromptSetEventHandlers(nullptr, &OnSpopPrompt, nullptr); if (FAILED(hr)) { // Handle SPOP setup failure } ``` Le gestionnaire doit présenter une interface utilisateur permettant au joueur de choisir une action (Sign In Here, Switch Account ou Cancel) et appeler `XUserPlatformSpopPromptComplete(operation, result)` avec le résultat choisi. ### 3. Implémentation de l'interface utilisateur d'authentification En plus des rappels d'interface utilisateur de Game Saves (section 3), l'intégration à l'écosystème XBOX nécessite : * **Une boîte de dialogue Remote Connect** : affiche le code QR et l'URL permettant aux utilisateurs de s'authentifier sur un autre appareil * **Une boîte de dialogue d'invite SPOP** : permet aux utilisateurs de sélectionner/confirmer leur gamertag XBOX ### 4. Séquence d'initialisation Suivez cette séquence d'initialisation pour l'intégration à l'écosystème XBOX : ```cpp theme={null} // 1. Check Steam availability and platform bool steamAvailable = SteamIntegration::CheckSteamAvailability(); bool isSteamDeck = SteamIntegration::CheckIfSteamDeck(); // 2. Set Xbox Live sandbox (Steam Deck only, required for non-retail sandbox testing) if (isSteamDeck) { HRESULT hr = SteamIntegration::SetSandboxForSteamDeck("XDKS.1"); if (FAILED(hr)) { // Handle sandbox setup failure return hr; } } // 3. Initialize Xbox runtime hr = XGameRuntimeInitialize(); if (FAILED(hr)) { return hr; } // 4. Initialize PlayFab Core and Services hr = PFInitialize(nullptr); if (FAILED(hr)) { return hr; } hr = PFServicesInitialize(nullptr); // Optional // 5. Initialize XUser for Steam Deck if (isSteamDeck) { hr = SteamIntegration::InitializeXUserForSteamDeck(); if (FAILED(hr)) { return hr; } } // 6. Initialize Game Saves with appropriate callbacks bool setUiCallbacks = isSteamDeck; hr = InitializeGameSaves(setUiCallbacks); if (FAILED(hr)) { return hr; } ``` ### 5. Implémentation de la déconnexion Le Steam Deck nécessite une gestion particulière de la déconnexion afin d'effacer les informations d'identification XBOX stockées : ```cpp theme={null} void SignOutFromSteamDeck() { // Enumerate and delete Windows credentials with target names starting with "Xbl" DWORD count = 0; PCREDENTIALW* credentials = nullptr; if (CredEnumerateW(L"Xbl*", 0, &count, &credentials)) { for (DWORD i = 0; i < count; i++) { CredDeleteW(credentials[i]->TargetName, credentials[i]->Type, 0); } CredFree(credentials); } // Close Xbox user handles if (xboxUser) { XUserCloseHandle(xboxUser); xboxUser = nullptr; } // Close PlayFab user handles if (pfUser) { PFLocalUserCloseHandle(pfUser); pfUser = nullptr; } // Reset authentication state for clean re-authentication authenticationState = AuthState::NotAuthenticated; } ``` ### 6. Liste de contrôle des tests Utilisez cette liste de contrôle pour valider votre implémentation avec l'écosystème XBOX : * [ ] **Flux d'authentification** : testez l'authentification Remote Connect (code QR/URL) * [ ] **Rappels d'interface utilisateur** : vérifiez que toutes les boîtes de dialogue de Game Saves s'affichent correctement * [ ] **Invites SPOP** : testez la sélection et la confirmation du gamertag * [ ] **Persistance des informations d'identification** : testez la persistance de la connexion d'un redémarrage de l'application à l'autre * [ ] **Déconnexion** : vérifiez que les informations d'identification sont correctement effacées lors de la déconnexion * [ ] **Comportement de synchronisation** : testez les synchronisations fréquentes et la synchronisation avant l'arrêt * [ ] **Prévention des pertes de données** : vérifiez qu'une progression minimale est perdue en cas de fermeture forcée * [ ] **Synchronisation multiplateforme** : testez la synchronisation des sauvegardes entre le Steam Deck, les consoles XBOX et le PC Microsoft Store * [ ] **Configuration du Registre** : vérifiez que la configuration du bac à sable fonctionne dans les environnements de développement * [ ] **Gestionnaires d'événements XUser** : confirmez le bon fonctionnement des gestionnaires Remote Connect et SPOP *** ## Approche 2 : implémentation d'une identité personnalisée - implémentation complète Cette approche vous permet d'utiliser votre propre système d'identité de joueur sans intégration XBOX Live. Choisissez cette approche si votre jeu est centré sur Steam ou si vous disposez déjà d'un système d'identité personnalisé. ### Vue d'ensemble **Prérequis** : * Avoir terminé la configuration commune (sections 1 à 3 ci-dessus) * Disposer d'un système d'identité de joueur personnalisé pour la production **Avantages** : * Aucune authentification XBOX requise * Aucune configuration du Registre nécessaire * Aucun privilège d'administrateur requis * Interface utilisateur plus simple (pas de code QR ni de sélection de gamertag) **Limitations** : * Vous devez implémenter votre propre identité de joueur multiplateforme * Aucune fonctionnalité sociale XBOX Live * Nécessite des solutions personnalisées de passerelle entre plateformes ### 1. Authentification par identité personnalisée Implémentez votre propre système d'identité pour l'authentification multiplateforme des joueurs : ```cpp theme={null} // Custom identity authentication if (isSteamDeck) { // Development/Testing: Use Steam user identity temporarily // Production: Implement your own cross-platform player identity system // Required for production since Steam Cloud handles Steam-only sync // Option 1: OpenID Connect Integration (Recommended) // If your identity system supports OpenID Connect, use LoginWithOpenIdConnect: // PFAuthenticationLoginWithOpenIdConnectRequest request = {}; // request.connectionId = "YourOpenIdConnectConnectionId"; // request.idToken = "YourOpenIdConnectToken"; // PFAuthenticationLoginWithOpenIdConnectAsync(serviceConfigHandle, &request, ...); // Option 2: Custom Integration // Initialize your custom authentication system // Connect to your user accounts/login system // Integrate with PlayFab Game Saves using your player identity // Initialize Game Saves with your custom identity system // (Implementation details depend on your specific identity integration) } ``` ### 2. Séquence d'initialisation ```cpp theme={null} // 1. Check Steam availability and platform bool steamAvailable = SteamIntegration::CheckSteamAvailability(); bool isSteamDeck = SteamIntegration::CheckIfSteamDeck(); // 2. Initialize Xbox runtime (still required for Game Saves infrastructure) HRESULT hr = XGameRuntimeInitialize(); if (FAILED(hr)) { return hr; } // 3. Initialize PlayFab Core and Services hr = PFInitialize(nullptr); if (FAILED(hr)) { return hr; } hr = PFServicesInitialize(nullptr); // Optional // 4. Initialize your custom player identity system hr = InitializeCustomPlayerIdentity(); if (FAILED(hr)) { return hr; } // 5. Initialize Game Saves with custom identity system // Option A: OpenID Connect (if your identity system supports it) // hr = PFAuthenticationLoginWithOpenIdConnectAsync(serviceConfigHandle, &openIdRequest, ...); // Option B: Custom authentication integration hr = InitializeGameSavesWithCustomIdentity(); if (FAILED(hr)) { return hr; } ``` ### 3. Implémentation de la déconnexion ```cpp theme={null} void SignOutFromSteamDeck() { // Sign-out for custom identity implementation // No Xbox credential cleanup needed // Clean up your custom identity system SignOutFromCustomIdentitySystem(); // Close PlayFab user handles if (pfUser) { PFLocalUserCloseHandle(pfUser); pfUser = nullptr; } // Clear local game state as needed ClearLocalGameState(); } ``` ### 4. Liste de contrôle des tests Utilisez cette liste de contrôle pour valider votre implémentation avec identité personnalisée : * [ ] **Système d'identité personnalisé** : testez votre système personnalisé d'authentification et d'identité des joueurs * [ ] **Authentification PlayFab** : testez la connexion PlayFab à l'aide de LoginWithOpenIdConnect (si vous utilisez OpenID Connect) ou de votre méthode d'authentification personnalisée * [ ] **Synchronisation multiplateforme de Game Saves** : testez la synchronisation des sauvegardes sur toutes les plateformes cibles * [ ] **Rappels d'interface utilisateur** : vérifiez que toutes les boîtes de dialogue de Game Saves s'affichent correctement * [ ] **Résolution des conflits** : testez les conflits de sauvegarde entre appareils de différentes plateformes * [ ] **Comportement de synchronisation** : testez les synchronisations fréquentes et la synchronisation avant l'arrêt * [ ] **Prévention des pertes de données** : vérifiez qu'une progression minimale est perdue en cas de fermeture forcée * [ ] **Authentification personnalisée** : testez les flux de connexion/déconnexion de votre système d'identité * [ ] **Couverture des plateformes** : testez sur toutes les plateformes ciblées par votre jeu (et pas uniquement les appareils Steam) * [ ] **Scénarios réseau** : testez les transitions hors connexion/en ligne * [ ] **Performances** : vérifiez que les opérations de synchronisation n'affectent pas les performances du jeu *** ## Référence des exemples de code Pour des exemples d'implémentation complets des deux approches, consultez l'exemple de projet : * **Emplacement** : [PlayFabGameSaveSample-Windows](https://github.com/PlayFab/PlayFab-Samples/tree/master/Samples/All/PlayFabGameSaveSample-Windows) * **Fichiers clés** : * `SteamIntegration.cpp/.h` : détection du Steam Deck, configuration du Registre, gestionnaires d'authentification * `GameSaveIntegrationUI.cpp/.h` : implémentations des rappels d'interface utilisateur pour les deux approches *** ## Documentation connexe * [Guide d'implémentation avec le GDK d'octobre 2025](/fr-CA/services/playfab/player-progression/game-saves/october-2025-gdk-changes) * [Vue d'ensemble de Game Saves](/fr-CA/services/playfab/player-progression/game-saves/overview) * [Démarrage rapide de Game Saves](/fr-CA/services/playfab/player-progression/game-saves/quickstart) ## Related topics - [Implémentation de Game Saves avec le GDK d'octobre 2025](/fr-CA/services/playfab/player-progression/game-saves/october-2025-gdk-changes.md) - [Rappels d'interface utilisateur de Game Saves](/fr-CA/services/playfab/player-progression/game-saves/ui-callbacks.md) - [Vue d'ensemble de Game Saves](/fr-CA/services/playfab/player-progression/game-saves/overview.md) - [Stratégies de liaison de comptes pour PlayFab Game Saves](/fr-CA/services/playfab/player-progression/game-saves/linking.md) - [Démarrage rapide de Game Saves](/fr-CA/services/playfab/player-progression/game-saves/quickstart.md)