> ## 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. # Inicio rápido de Android > Configure el SDK de C de PlayFab Services en Android Studio, agregue las bibliotecas nativas y realice su primera llamada a la API de PlayFab desde un proyecto de Android. # Inicio rápido: Android Introducción al SDK de PlayFab Services para Android. Siga estos pasos para incluir las bibliotecas en su proyecto y probar el código de ejemplo de las funciones básicas de PlayFab. Este inicio rápido le ayuda a realizar su primera llamada a la API de PlayFab con el SDK de Android. Antes de continuar, asegúrese de haber completado los pasos de [Inicio rápido: Game Manager](/services/playfab/live-service-management/gamemanager/quickstart), que garantizan que tiene una cuenta de PlayFab y que está familiarizado con Game Manager de PlayFab. ## Requisitos * Una [cuenta de desarrollador de PlayFab](https://developer.playfab.com). * [Android Studio](https://developer.android.com/studio) instalado. ## Configuración del proyecto Descargue el SDK de PlayFab para Android en su proyecto desde la [página de versiones del SDK de PlayFab](https://github.com/PlayFab/PlayFabCSdk/releases/latest). ### Integración del SDK de C de PlayFab en su propio proyecto Los pasos siguientes están escritos partiendo del supuesto de que ha creado un proyecto nuevo con Android Studio. #### Adición de archivos binarios al juego Hay dos partes de los archivos binarios que deberá integrar en su proyecto: los archivos de objetos compartidos (.so) y los archivos de Android Archive (.aar). Puede compilar los archivos binarios usted mismo o descargarlos desde la página de versiones. #### Adición de los archivos .so Estos archivos se integran en su proyecto mediante CMake. 1. Descomprima la versión del SDK de PlayFab para Android y coloque su contenido en el directorio que desee. 2. Con **target\_include\_directories** u otra función equivalente, agregue los encabezados que se encuentran en "Include" de la versión del SDK de PlayFab: ```cmake theme={null} TARGET_INCLUDE_DIRECTORIES( ${PROJECT_NAME} "Include" ) ``` 3. Con **target\_link\_libraries** u otra función equivalente, vincule las ubicaciones de los archivos .so a su proyecto. Por ejemplo: ```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} ) ``` #### Adición de los archivos .aar Estos archivos se integran en su proyecto mediante Gradle. 1. Cree una carpeta libs dentro del directorio del proyecto de Android en el nivel de aplicación. Este es un ejemplo del aspecto que debería tener ahora el directorio del proyecto: Directorio del proyecto 2. Copie los archivos .aar en la carpeta libs. 3. En el archivo build.gradle de nivel de aplicación, el que está en el mismo directorio que la carpeta libs, agregue estas líneas a la sección de dependencias. La segunda línea es necesaria como dependencia de libHttpClient. ```gradle theme={null} implementation fileTree(dir: 'libs', include: ['*.aar']) implementation 'com.squareup.okhttp3:okhttp:4.9.1' ``` ## Inicialización e inicio de sesión Ahora que el proyecto está totalmente configurado para usar el SDK de PlayFab Services para Android, siga los pasos siguientes para hacer funcionar algunas llamadas de ejemplo. ### Configuración inicial Primero deberá configurar la aplicación para que tenga una instancia de una [actividad](https://developer.android.com/reference/android/app/Activity) de Android. También deberá configurar una pequeña aplicación C/C++ para usar el NDK con la JNI (Java Native Interface). Aquí tiene un pequeño ejemplo de referencia: [https://github.com/android/ndk-samples/tree/android-mk/hello-jni](https://github.com/android/ndk-samples/tree/android-mk/hello-jni). El ejemplo contiene un método nativo que devuelve un jstring: ```cpp theme={null} jstring Java_com_example_hellojni_HelloJni_stringFromJNI(JNIEnv* env, jobject thiz) ``` Los métodos nativos se pueden usar para obtener la máquina virtual de Java y el contexto de la aplicación, dos elementos necesarios para inicializar PFServices. Puede crear un método similar con fines de inicialización: ```cpp theme={null} void Java_com_example_hellojni_HelloJni_InitializeApp(JNIEnv* env, jobject appContext) ``` Después, la máquina virtual de Java se puede recuperar mediante la variable JNIEnv. ```cpp theme={null} JavaVM* javaVM = nullptr; jint res = env->GetJavaVM(&javaVM); if (res != JNI_OK) { // error handling } ``` A continuación, el contexto de la aplicación se puede obtener con el parámetro jobject. ```cpp theme={null} applicationContext = env->NewGlobalRef(appContext); ``` Ahora que ha almacenado estas dos variables, podemos empezar a realizar llamadas. ### Encabezados Incluya **PFServices.h** para obtener acceso a toda la funcionalidad de PlayFab incluida: ```cpp theme={null} #include ``` ### Inicialización La inicialización de PlayFab requiere dos llamadas de función: **PFServicesInitialize** y **PFServiceConfigCreateHandle**. El resultado de esta inicialización es un **PFServiceConfigHandle**. Proporcione este identificador a una llamada de inicio de sesión posterior para dirigir la llamada al título correcto en el back-end de 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); ``` ### Inicio de sesión Una vez que tenga un **PFServiceConfigHandle**, puede usarlo para realizar una llamada de inicio de sesión de jugador. En el SDK, use un método **PFAuthenticationLoginWith\*Async** como **PFAuthenticationLoginWithCustomIDAsync**. Esta función le permite iniciar la sesión de un jugador en PlayFab mediante un identificador personalizado. Después de realizar una llamada de inicio de sesión, puede comprobar el estado de la llamada con **XAsyncGetStatus**. El estado comienza como **E\_PENDING** y cambia a **S\_OK** una vez que la llamada se completa correctamente. Si la llamada produce un error por algún motivo, el estado refleja ese error. El control de errores en todas las llamadas de PlayFab Services funciona de esta manera. Junto con un resultado **S\_OK**, recibe un **PFEntityHandle**. Use este identificador para realizar llamadas posteriores a PlayFab como el jugador que inició sesión. Incluye todo el material necesario para autenticarse en el servicio de PlayFab como ese jugador. ```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); ``` ## Llamadas al servicio Después de que el jugador inicie sesión, ya puede realizar llamadas al back-end de PlayFab. Este es un ejemplo de una llamada para obtener los archivos almacenados en PlayFab para el jugador actual. ### Obtención de EntityKey Algo que puede resultar útil para algunas llamadas a PlayFab es conocer la **PFEntityKey** del jugador. Una vez que tenga un **PFEntityToken**, puede recuperar una **PFEntityKey** con **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); ``` ### Llamada a GetFiles Todas las llamadas de PlayFab siguen un patrón similar: preparar el objeto de solicitud, realizar la llamada (mediante el **PFEntityHandle** del inicio de sesión), crear un objeto para recibir la respuesta y, después, llamar a una función **GetResult** para rellenar el contenedor recién creado. ```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); ``` ## Limpieza Cuando el juego esté listo para cerrarse o necesite limpiar PlayFab por algún otro motivo, asegúrese de cerrar todos los identificadores abiertos y llamar a **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 ``` ## Patrón de API asincrónica El SDK de PlayFab Services sigue el [modelo de programación asincrónica](https://learn.microsoft.com/en-us/gaming/gdk/_content/gc/system/overviews/async-programming-model) implementado en el GDK. Este modelo de programación implica el uso de tareas y colas de tareas proporcionadas por la [biblioteca XAsync](/build/core-features/common/async/async-libraries/async-library-xasync). Este modelo es coherente con otras funciones y extensiones del GDK (como la API de XBOX Services). Aunque presenta cierta complejidad, también aporta un alto grado de control sobre las operaciones asincrónicas. En este ejemplo se muestra cómo realizar una llamada asincrónica a **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 } ``` ## Control de errores Las operaciones **XAsync** completadas devuelven códigos de estado HTTP. Un código de estado de error se manifiesta como un **HRESULT** de error, como **HTTP\_E\_STATUS\_NOT\_FOUND**, al llamar a **XAsyncGetStatus()** o a una de las API **PF\*Get()**. Para ver los mensajes de error detallados que devuelve el servicio, consulte la sección siguiente sobre depuración. Estos mensajes de error detallados pueden ser útiles durante el desarrollo para comprender mejor cómo reacciona el servicio de PlayFab a las solicitudes del cliente. ## Depuración La manera más fácil de ver los resultados y depurar las llamadas en el SDK de PlayFab Services es habilitar el [seguimiento de depuración](/services/playfab/sdks/c/tracing). Habilitar el seguimiento de depuración le permite ver los resultados en la ventana de salida del depurador y conectar los resultados a los registros propios de su juego. ## Referencia [Documentación de referencia de la API](/services/playfab/api-references/c/pfauthentication/pfauthentication_members) ## Related topics - [Inicio rápido de Java para Native y Android Studio](/es/services/playfab/sdks/java/quickstart.md) - [Inicio rápido de notificaciones push](/es/services/playfab/live-service-management/game-configuration/title-communications/push-notifications/quickstart.md) - [Inicio rápido de métricas](/es/services/playfab/data-analytics/learn-data/trends/trends-quickstart.md) - [Guía de inicio rápido de prevención de fraude](/es/services/playfab/economy-monetization/economy-v2/fraud-prevention/quickstart.md) - [Inicio rápido de Unity](/es/services/playfab/sdks/unity3d/quickstart.md)