> ## 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 Android > Configurez le SDK C PlayFab Services dans Android Studio, ajoutez les bibliothèques natives et effectuez votre premier appel d'API PlayFab depuis un projet Android. # Démarrage rapide : Android Prenez en main le SDK PlayFab Services pour Android. Suivez ces étapes pour inclure les bibliothèques dans votre projet et essayer l'exemple de code des fonctionnalités PlayFab de base. Ce démarrage rapide vous aide à effectuer votre premier appel d'API PlayFab à l'aide du SDK Android. Avant de continuer, assurez-vous d'avoir suivi les étapes de [Démarrage rapide : Game Manager](/fr-CA/services/playfab/live-service-management/gamemanager/quickstart), qui garantissent que vous disposez d'un compte PlayFab et que vous connaissez PlayFab Game Manager. ## Configuration requise * Un [compte de développeur PlayFab](https://developer.playfab.com). * [Android Studio](https://developer.android.com/studio) installé. ## Configuration du projet Téléchargez le SDK PlayFab Android dans votre projet depuis la [page des versions du SDK PlayFab](https://github.com/PlayFab/PlayFabCSdk/releases/latest). ### Intégrer le SDK C PlayFab à votre propre projet Les étapes suivantes partent du principe que vous avez créé un nouveau projet avec Android Studio. #### Ajouter les binaires à votre jeu Vous devez intégrer deux types de binaires à votre projet : les fichiers d'objets partagés (.so) et les fichiers d'archive Android (.aar). Vous pouvez générer vous-même les binaires ou les télécharger depuis la page des versions. #### Ajouter les fichiers .so Ces fichiers sont intégrés à votre projet à l'aide de CMake. 1. Décompressez la version du SDK PlayFab pour Android et placez son contenu dans le répertoire de votre choix. 2. À l'aide de **target\_include\_directories** ou d'une autre fonction équivalente, ajoutez les en-têtes situés sous "Include" dans la version du SDK PlayFab : ```cmake theme={null} TARGET_INCLUDE_DIRECTORIES( ${PROJECT_NAME} "Include" ) ``` 3. À l'aide de **target\_link\_libraries** ou d'une autre fonction équivalente, liez les emplacements des fichiers .so à votre projet. Par exemple : ```cmake theme={null} set(PLAYFAB_SERVICES_PATH "[LOCATION OF YOUR FILE]/libPlayFabServices.Android.so") set(PLAYFAB_CORE_PATH "[LOCATION OF YOUR FILE]/libPlayFabCore.Android.so") set(LIBHTTPCLIENT_PATH "[LOCATION OF YOUR FILE]/libHttpClient.Android.so") TARGET_LINK_LIBRARIES( [YOUR PROJECT NAME] ${PLAYFAB_SERVICES_PATH} ${PLAYFAB_CORE_PATH} ${LIBHTTPCLIENT_PATH} ) ``` #### Ajouter les fichiers .aar Ces fichiers sont intégrés à votre projet à l'aide de Gradle. 1. Créez un dossier libs dans le répertoire du projet Android au niveau de l'application. Voici un exemple de ce à quoi devrait désormais ressembler le répertoire de votre projet : Répertoire du projet 2. Copiez les fichiers .aar dans le dossier libs. 3. Dans le fichier build.gradle au niveau de l'application, celui qui se trouve dans le même répertoire que le dossier libs, ajoutez ces lignes à la section dependencies. La deuxième ligne est requise en tant que dépendance de libHttpClient. ```gradle theme={null} implementation fileTree(dir: 'libs', include: ['*.aar']) implementation 'com.squareup.okhttp3:okhttp:4.9.1' ``` ## Initialisation et connexion Maintenant que votre projet est entièrement configuré pour utiliser le SDK PlayFab Services pour Android, suivez les étapes suivantes pour faire fonctionner quelques exemples d'appels. ### Configuration initiale Vous devez d'abord configurer votre application pour qu'elle dispose d'une instance d'[activité](https://developer.android.com/reference/android/app/Activity) Android. Vous devez également configurer une petite application C/C++ pour utiliser le NDK avec JNI (Java Native Interface). Voici un petit exemple de référence : [https://github.com/android/ndk-samples/tree/android-mk/hello-jni](https://github.com/android/ndk-samples/tree/android-mk/hello-jni). L'exemple contient une méthode native qui retourne un jstring : ```cpp theme={null} jstring Java_com_example_hellojni_HelloJni_stringFromJNI(JNIEnv* env, jobject thiz) ``` Les méthodes natives peuvent servir à obtenir la machine virtuelle Java et le contexte de l'application, deux éléments nécessaires à l'initialisation de PFServices. Vous pouvez créer une méthode similaire à des fins d'initialisation : ```cpp theme={null} void Java_com_example_hellojni_HelloJni_InitializeApp(JNIEnv* env, jobject appContext) ``` La machine virtuelle Java peut ensuite être récupérée à l'aide de la variable JNIEnv. ```cpp theme={null} JavaVM* javaVM = nullptr; jint res = env->GetJavaVM(&javaVM); if (res != JNI_OK) { // error handling } ``` Le contexte de l'application peut ensuite être obtenu à l'aide du paramètre jobject. ```cpp theme={null} applicationContext = env->NewGlobalRef(appContext); ``` Maintenant que ces deux variables sont stockées, nous pouvons commencer à effectuer des appels. ### En-têtes Incluez **PFServices.h** pour accéder à toutes les fonctionnalités PlayFab incluses : ```cpp theme={null} #include ``` ### Initialisation L'initialisation de PlayFab nécessite deux appels de fonction : **PFServicesInitialize** et **PFServiceConfigCreateHandle**. Le résultat de cette initialisation est un **PFServiceConfigHandle**. Vous fournissez ce handle à un appel de connexion ultérieur, afin de diriger l'appel vers le bon titre dans le back-end PlayFab. ```cpp theme={null} HCInitArgs initArgs; // Use the Java VM and application context from earlier initArgs.javaVM = javaVm; initArgs.applicationContext = applicationContext; HRESULT hr = PFServicesInitialize(nullptr, &initArgs); // Add your own error handling when FAILED(hr) == true PFServiceConfigHandle serviceConfigHandle{ nullptr }; hr = PFServiceConfigCreateHandle( "https://ABCDEF.playfabapi.com", // PlayFab API endpoint - obtained in the Game Manager "ABCDEF", // PlayFab Title id - obtained in the Game Manager &serviceConfigHandle); ``` ### Connexion Une fois que vous disposez d'un **PFServiceConfigHandle**, vous pouvez l'utiliser pour effectuer un appel de connexion de joueur. Dans le SDK, utilisez une méthode **PFAuthenticationLoginWith\*Async** telle que **PFAuthenticationLoginWithCustomIDAsync**. Cette fonction vous permet de connecter un joueur à PlayFab à l'aide d'un ID personnalisé. Après un appel de connexion, vous pouvez vérifier l'état de l'appel avec **XAsyncGetStatus**. L'état est initialement **E\_PENDING** et passe à **S\_OK** une fois l'appel terminé avec succès. Si l'appel échoue pour une raison quelconque, l'état reflète cet échec. La gestion des erreurs fonctionne de cette façon pour tous les appels PlayFab Services. Avec un résultat **S\_OK**, vous obtenez un **PFEntityHandle**. Vous utilisez ce handle pour effectuer les appels PlayFab suivants en tant que joueur connecté. Il contient tous les éléments nécessaires pour s'authentifier auprès du service PlayFab en tant que ce joueur. ```cpp theme={null} PFAuthenticationLoginWithCustomIDRequest request{}; request.createAccount = true; request.customId = "player1"; XAsyncBlock async{}; HRESULT hr = PFAuthenticationLoginWithCustomIDAsync(serviceConfigHandle, &request, &async); // Add your own error handling when FAILED(hr) == true 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 std::vector loginResultBuffer; PFAuthenticationLoginResult const* loginResult; size_t bufferSize; hr = PFAuthenticationLoginWithCustomIDGetResultSize(&async, &bufferSize); loginResultBuffer.resize(bufferSize); PFEntityHandle entityHandle{ nullptr }; hr = PFAuthenticationLoginWithCustomIDGetResult(&async, &entityHandle, loginResultBuffer.size(), loginResultBuffer.data(), &loginResult, nullptr); ``` ## Appels de service Une fois le joueur connecté, vous pouvez effectuer des appels au back-end PlayFab. Voici un exemple d'appel permettant d'obtenir les fichiers stockés dans PlayFab pour le joueur actuel. ### Obtenir l'EntityKey Pour certains appels à PlayFab, il peut être utile de connaître la **PFEntityKey** du joueur. Une fois que vous disposez d'un **PFEntityToken**, vous pouvez récupérer une **PFEntityKey** avec **PFEntityGetEntityKey**. ```cpp theme={null} PFEntityKey const* pEntityKey{}; std::vector entityKeyBuffer; size_t size{}; HRESULT hr = PFEntityGetEntityKeySize(entityHandle, &size); // Add your own error handling when FAILED(hr) == true entityKeyBuffer.resize(size); hr = PFEntityGetEntityKey(entityHandle, entityKeyBuffer.size(), entityKeyBuffer.data(), &pEntityKey, nullptr); ``` ### Appeler GetFiles Tous les appels PlayFab suivent un modèle similaire : préparation de l'objet de requête, appel (à l'aide du **PFEntityHandle** obtenu lors de la connexion), création d'un objet destiné à recevoir la réponse, puis appel d'une fonction **GetResult** pour remplir le conteneur nouvellement créé. ```cpp theme={null} XAsyncBlock async{}; PFDataGetFilesRequest requestFiles{}; requestFiles.entity = pEntityKey; HRESULT hr = PFDataGetFilesAsync(entityHandle, &requestFiles, &async); // Add your own error handling when FAILED(hr) == true 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 size_t resultSize; hr = PFDataGetFilesGetResultSize(&async, &resultSize); std::vector getFilesResultBuffer(resultSize); PFDataGetFilesResponse* getFilesResponseResult{ nullptr }; hr = PFDataGetFilesGetResult(&async, getFilesResultBuffer.size(), getFilesResultBuffer.data(), &getFilesResponseResult, nullptr); ``` ## Nettoyage Lorsque votre jeu est prêt à s'arrêter, ou si vous devez nettoyer PlayFab pour une autre raison, assurez-vous de fermer tous les handles ouverts et à appeler **PFServicesUninitializeAsync**. ```cpp theme={null} PFEntityCloseHandle(entityHandle); entityHandle = nullptr; PFServiceConfigCloseHandle(serviceConfigHandle); serviceConfigHandle = nullptr; XAsyncBlock async{}; HRESULT hr = PFServicesUninitializeAsync(&async); // Add your own error handling when FAILED(hr) == true 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 ``` ## Modèle d'API asynchrone Le SDK PlayFab Services suit le [modèle de programmation asynchrone](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/system/overviews/async-programming-model) implémenté dans le GDK. Ce modèle de programmation implique l'utilisation de tâches et de files d'attente de tâches fournies par la [bibliothèque XAsync](/fr-CA/build/core-features/common/async/async-libraries/async-library-xasync). Ce modèle est cohérent avec les autres fonctions et extensions du GDK (comme l'API XBOX Services). Bien qu'il introduise une certaine complexité, il offre également un haut niveau de contrôle sur les opérations asynchrones. Cet exemple montre comment effectuer un appel asynchrone à **PFDataGetFilesAsync**. ```cpp theme={null} auto async = std::make_unique(); async->callback = [](XAsyncBlock* async) { std::unique_ptr asyncBlockPtr{ async }; // take ownership of XAsyncBlock size_t resultSize; HRESULT hr = PFDataGetFilesGetResultSize(async, &resultSize); if (SUCCEEDED(hr)) { std::vector getFilesResultBuffer(resultSize); PFDataGetFilesResponse* getFilesResponseResult{ nullptr }; PFDataGetFilesGetResult(async, getFilesResultBuffer.size(), getFilesResultBuffer.data(), &getFilesResponseResult, nullptr); } }; PFDataGetFilesRequest requestFiles{}; requestFiles.entity = m_pEntityKey; HRESULT hr = PFDataGetFilesAsync(m_entityHandle, &requestFiles, async.get()); if (SUCCEEDED(hr)) { async.release(); // at this point, the callback will be called so release the unique ptr } ``` ## Gestion des erreurs Les opérations **XAsync** terminées retournent des codes d'état HTTP. Un code d'état d'erreur se traduit par un **HRESULT** d'échec, tel que **HTTP\_E\_STATUS\_NOT\_FOUND**, lors de l'appel de **XAsyncGetStatus()** ou de l'une des API **PF\*Get()**. Pour afficher les messages d'erreur détaillés retournés par le service, consultez la section suivante sur le débogage. Ces messages d'erreur détaillés peuvent être utiles pendant le développement pour mieux comprendre comment le service PlayFab réagit aux requêtes du client. ## Débogage Le moyen le plus simple d'afficher les résultats et de déboguer les appels du SDK PlayFab Services consiste à activer le [traçage de débogage](/fr-CA/services/playfab/sdks/c/tracing). L'activation du traçage de débogage vous permet à la fois d'afficher les résultats dans la fenêtre de sortie du débogueur et de les intégrer aux journaux de votre jeu. ## Référence [Documentation de référence de l'API](/fr-CA/services/playfab/api-references/c/pfauthentication/pfauthentication_members) ## Related topics - [Langages pris en charge par PlayFab](/fr-CA/services/playfab/sdks/languages/index.md) - [Plateformes prises en charge par PlayFab](/fr-CA/services/playfab/sdks/platforms/index.md) - [Démarrage rapide Java pour Java natif et Android Studio](/fr-CA/services/playfab/sdks/java/quickstart.md) - [Démarrage rapide de Party](/fr-CA/services/playfab/multiplayer/networking/quickstart.md) - [Démarrage rapide des notifications push](/fr-CA/services/playfab/live-service-management/game-configuration/title-communications/push-notifications/quickstart.md)