Organiza tus páginas con colecciones
Guarda y categoriza el contenido según tus preferencias.
Después de la baja de la API de Acceso a Google, quitaremos el SDK de juegos v1 en 2026. Después de febrero de 2025, no podrás publicar títulos que se hayan integrado recientemente con el SDK de juegos v1 en Google Play. Te recomendamos que uses el SDK de juegos v2.
Si bien los títulos existentes con las integraciones de la versión 1 de los juegos anteriores seguirán funcionando durante un
par de años, te recomendamos que
migres a la versión 2
a partir de junio de 2025.
Esta guía se aplica al uso del SDK de la versión 1 de los Servicios de juego de Play. El SDK de C++ para la versión 2 de los Servicios de juego de Play aún no está disponible.
El SDK C++ de los servicios de juego de Google Play proporciona una API de C++ para usar con los servicios de juego de Google Play y está orientado a desarrolladores que ya poseen una implementación de su juego en C++.
Actualmente, el SDK implementa los siguientes servicios:
Autorización
Logros
Tablas de clasificación
Eventos
Juegos guardados
Conexiones cercanas (solo Android)
Estadísticas del jugador
Conceptos
En un nivel superior, para utilizar el SDK debes seguir estos pasos:
Establece una configuración de plataforma para Android.
Usa un GameServices::Builder para configurar y construir un objeto GameServices. El objeto GameServices intenta acceder de forma automática y devuelve el resultado mediante una devolución de llamada OnAuthActionFinished(). Anota el resultado de la devolución de llamada. Si falla el intento de acceso automático, puedes mostrar un botón que permita a los usuarios acceder.
Después de recibir el resultado de OnAuthActionFinished(), puedes usar el objeto GameServices y sus administradores secundarios para realizar llamadas a los servicios de juego de Play, incluidas las siguientes:
Acceso (después de que falla la autorización): StartAuthorizationUI()
Desbloqueo de logros: Achievements().Unlock()
Muestra logros con una IU integrada: Achievements().ShowAllUI()
Envío de una puntuación alta: Leaderboards().SubmitScore()
Salir: SignOut()
Cuando termines de usar el objeto GameServices, restablécelo o destrúyelo.
En un nivel más detallado:
Inicializa una configuración de plataforma. El objeto contiene información de inicialización específica para la plataforma. En Android, la configuración de plataforma contiene la VM de Java y un puntero a la Activity actual:
// In android_main(), create a platform configuration// and bind the object activity.// Alternately, attach the activity in JNI_Onload().gpg::AndroidPlatformConfigurationplatform_configuration;platform_configuration.SetActivity(state->activity->clazz);
Construye un objeto GameServices. Este objeto es el punto de entrada principal para la funcionalidad de los servicios de juego de Google Play. Las instancias de GameServices se crean con GameServices::Builder.
En la mayoría de las implementaciones, un objeto GameServices determinado persistirá lo que dure tu entorno C; no es necesario que lo reinicies cuando se pause y reanude la Activity de Android.
// Creates a GameServices object that has lambda callbacks.game_services_=gpg::GameServices::Builder().SetDefaultOnLog(gpg::LogLevel::VERBOSE).SetOnAuthActionStarted([started_callback](gpg::AuthOperationop){is_auth_in_progress_=true;started_callback(op);}).SetOnAuthActionFinished([finished_callback](gpg::AuthOperationop,gpg::AuthStatusstatus){LOGI("Sign in finished with a result of %d",status);is_auth_in_progress_=false;finished_callback(op,status);}).Create(pc);
Usa las clases de administrador para administrar tu objeto GameServices. El acceso a los administradores se obtiene desde una instancia de GameServices y estos agrupan la funcionalidad relacionada. Algunos ejemplos incluyen los administradores de logros y tablas de posiciones. Estos no poseen estados visibles para el usuario. Los administradores se devuelven como referencia y la instancia de GameServices que contienen controla su ciclo de vida. El cliente nunca debe aferrarse a una referencia de administrador. En cambio, debe aferrarse a la instancia de GameServices.
Los administradores devuelven datos mediante objetos de valor invariable. Esos valores reflejan una vista constante de los datos subyacentes en el momento en que se realizó la consulta.
// Submit a high scoregame_services_->Leaderboards().SubmitScore(leaderboard_id,score);// Show the default Achievements UIgame_services_->Achievements().ShowAllUI();
Cuando termines de usar el objeto GameServices, límpialo mediante una llamada a reset() en el unique_ptr al que pertenece o deja que el unique_ptr lo destruya automáticamente cuando esté fuera de alcance.
Modelo de subprocesos
A menos que se indique lo contrario, todos los métodos de GameServices y del administrador tienen implementaciones asíncronas y seguras para subprocesos. Se los puede llamar en cualquier subproceso sin bloqueo externo y se ejecutarán
en un orden coherente con el orden de invocación.
Los métodos de descriptores de acceso (aquellos que leen el estado) se encuentran disponibles en dos variantes principales. El primer tipo de método (con nombres como FetchProperty()) suministra de forma asíncrona sus resultados a una devolución de llamada proporcionada; el segundo (con nombres como FetchPropertyBlocking()) devuelve de forma asíncrona sus resultados al subproceso que realizó la llamada.
Todas las callbacks del usuario se invocan en un subproceso de callback exclusivo. Este subproceso es potencialmente distinto a cualquier concepto de plataforma de un "subproceso principal" o "subproceso de IU". También debes tratar de asegurarte de que las devoluciones de llamada del usuario se ejecuten rápidamente; la interrupción de un subproceso de devolución de llamada puede provocar problemas visibles para el usuario (por ejemplo, demoras en la ejecución de una solicitud de salida de la cuenta).
Información específica de la plataforma
Para comenzar a usar el SDK de C++ para Play Juegos en Android, continúa a la guía de inicio rápido.
Lecturas adicionales
Asegúrate de leer la documentación de clase que incluye el SDK de C++ de los servicios de juego de Google Play para obtener más detalles y consulta las muestras que indican cómo usar el SDK.
El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.
Última actualización: 2025-07-26 (UTC)
[[["Fácil de comprender","easyToUnderstand","thumb-up"],["Resolvió mi problema","solvedMyProblem","thumb-up"],["Otro","otherUp","thumb-up"]],[["Falta la información que necesito","missingTheInformationINeed","thumb-down"],["Muy complicado o demasiados pasos","tooComplicatedTooManySteps","thumb-down"],["Desactualizado","outOfDate","thumb-down"],["Problema de traducción","translationIssue","thumb-down"],["Problema con las muestras o los códigos","samplesCodeIssue","thumb-down"],["Otro","otherDown","thumb-down"]],["Última actualización: 2025-07-26 (UTC)"],[],[],null,["# Play Games Services for C++\n\nFollowing the deprecation of the\n[Google Sign-In](https://android-developers.googleblog.com/2024/09/streamlining-android-authentication-credential-manager-replaces-legacy-apis.html)\nAPI, we are removing the games v1 SDK in 2026. After February 2025, you will be unable to publish\ntitles that are newly integrated with games v1 SDK, on Google Play. We recommend that you use the\ngames v2 SDK instead. \n\nWhile existing titles with the previous games v1 integrations continue to function for a\ncouple of years, you are encouraged to\n[migrate to v2](/games/pgs/android/migrate-to-v2)\nstarting June 2025. \n\nThis guide is for using the Play Games Services v1 SDK. The C++ SDK for\nPlay Games Services v2 is not yet available.\n\nThe Google Play games Services C++ SDK provides a C++ API for use with Google Play Game\nservices, and is meant for developers who have an existing C++ implementation\nof their game.\n\nCurrently, the SDK implements the following services:\n\n- Authorization\n- Achievements\n- Leaderboards\n- Events\n- Saved Games\n- Nearby Connections (Android only)\n- Player Statistics\n\nConcepts\n--------\n\nAt a high level, you use the SDK by following these steps:\n\n1. Set up a platform configuration for Android.\n2. Use a `GameServices::Builder` to configure and construct a `GameServices` object. The `GameServices` object automatically attempts to sign in, and returns the result via an `OnAuthActionFinished()` callback. Take note of the result returned by the callback. If the automatic sign-in attempt failed, you can display a button to let users sign in.\n3. After receiving the `OnAuthActionFinished()` result, you can use the\n `GameServices` object and its child Managers to make Play Games services calls,\n including:\n\n - Sign in (after authorization fails): `StartAuthorizationUI()`\n - Unlock achievements: `Achievements().Unlock()`\n - Show achievements using built-in UI: `Achievements().ShowAllUI()`\n - Submit a high score: `Leaderboards().SubmitScore()`\n - Sign out: `SignOut()`\n4. When you are done using the `GameServices` object, reset or destroy it.\n\nAt a more detailed level:\n\n1. Initialize a platform configuration: This is an object that contains\n platform-specific initialization information. On Android, the platform configuration contains the\n Java VM and a pointer to the current `Activity`:\n\n // In android_main(), create a platform configuration\n // and bind the object activity.\n // Alternately, attach the activity in JNI_Onload().\n gpg::AndroidPlatformConfiguration platform_configuration;\n platform_configuration.SetActivity(state-\u003eactivity-\u003eclazz);\n\n2. Construct a `GameServices` object: This object is the main entry point for\n Google Play games Services functionality. `GameServices` instances are created\n with `GameServices::Builder`.\n\n In most implementations, a given `GameServices` object will persist as long as\n your C environment does; you do not need to reinitialize it when your\n Android `Activity` pauses and resumes. \n\n // Creates a GameServices object that has lambda callbacks.\n game_services_ = gpg::GameServices::Builder()\n .SetDefaultOnLog(gpg::LogLevel::VERBOSE)\n .SetOnAuthActionStarted([started_callback](gpg::AuthOperation op) {\n is_auth_in_progress_ = true;\n started_callback(op);\n })\n .SetOnAuthActionFinished([finished_callback](gpg::AuthOperation op,\n gpg::AuthStatus status) {\n LOGI(\"Sign in finished with a result of %d\", status);\n is_auth_in_progress_ = false;\n finished_callback(op, status);\n })\n .Create(pc);\n\n3. Use the Manager classes to manage your `GameServices` object. Managers are accessed from a `GameServices` instance and group related functionality\n together. Examples of these\n include the Achievement and Leaderboard Managers. They contain no user-visible\n state themselves. Managers are returned by reference, and the containing\n `GameServices` instance controls their lifecycle. Your client should never hold\n onto a Manager reference. Instead, your client should hold on to the\n `GameServices` instance.\n\n Managers return data via immutable value type objects. These values\n reflect a consistent view of the underlying data at the point in time when\n the query was made. \n\n // Submit a high score\n game_services_-\u003eLeaderboards().SubmitScore(leaderboard_id, score);\n\n // Show the default Achievements UI\n game_services_-\u003eAchievements().ShowAllUI();\n\n4. When you are finished using the `GameServices` object, clean up by\n calling `reset()` on the `unique_ptr` that owns it, or by letting the\n `unique_ptr` automatically destroy it when going out of scope.\n\nThreading model\n---------------\n\nUnless otherwise noted, all `GameServices` and Manager methods have\nthread-safe, asynchronous implementations. They can be called on any thread without\nexternal locking, and will execute in an order consistent with their invocation\norder.\n\nAccessor methods (those that read state) come in two major variants. The first\ntype of method (with names like `FetchProperty()`) asynchronously supplies its results\nto a provided callback; the second (with names like\n`FetchPropertyBlocking()`) synchronously returns its results to the calling\nthread. \n\n // Blocking callback\n gpg::AchievementManager::FetchAllResponse fetchResponse =\n game_services_-\u003eAchievements().FetchAllBlocking(std::chrono::milliseconds(1000));\n\n // Non-blocking callback\n game_services_-\u003eAchievements().FetchAll(gpg::DataSource::CACHE_OR_NETWORK,\n [] (gpg::AchievementManager::FetchAllResponse response) {\n LogI(\"Achievement response status: %d\", response.status);});\n\nAll user callbacks are invoked on a dedicated callback thread. This thread is\npotentially distinct from any platform concept of a \"main thread\" or \"UI\nthread\". You should also try to ensure that user callbacks execute quickly; a stalled callback thread\nmay cause user-visible issues (for example, delayed completion of a sign-out\nrequest).\n\nPlatform-specific information\n-----------------------------\n\nTo get started using the Play Games C++ SDK on Android, continue to the\n[quickstart guide](/games/pgs/v1/cpp/quickstart).\n\nFurther reading\n---------------\n\nBe sure to read the class documentation that comes in the Google Play Game\nservices C++ SDK for further details, and check out the\n[samples](https://github.com/playgameservices/) that demonstrate how to use the SDK.\n\nIf your game uses a backend server, see\n[Enabling Server-Side Access to Google Play Games Services](/games/pgs/v1/android/server-access)."]]
