Serviços relacionados a jogos do Google Play para C++
Mantenha tudo organizado com as coleções
Salve e categorize o conteúdo com base nas suas preferências.
Após a descontinuação da
API Google Sign-In, vamos remover o SDK v1 de jogos em 2026. A partir de fevereiro de 2025, não será mais possível publicar
títulos recém-integrados ao SDK v1 para jogos no Google Play. Recomendamos que você use o
SDK v2 para jogos.
Embora os títulos atuais com as integrações anteriores dos jogos da v1 continuem funcionando por
alguns anos, recomendamos que você
migre para a v2
a partir de junho de 2025.
Este guia é para usar o SDK dos serviços relacionados a jogos do Google Play v1. O SDK C++ para
os serviços relacionados a jogos do Google Play v2 ainda não está disponível.
O SDK C++ dos serviços relacionados a jogos do Google Play fornece uma API C++ para uso com esses serviços. Ele destina-se a desenvolvedores que têm uma implementação C++ do jogo.
Atualmente, o SDK implementa os seguintes serviços:
Autorização
Conquista
Placares
Eventos
Jogos salvos
Nearby Connections (somente Android)
Estatísticas do jogador
Conceitos
Em um alto nível, use o SDK seguindo estes passos:
Defina a configuração de plataforma para Android.
Use um GameServices::Builder para configurar e criar um objeto
GameServices. O objeto GameServices tenta fazer login automaticamente e retorna
o resultado usando um callback OnAuthActionFinished(). Anote o resultado retornado pelo callback. Se a tentativa de login automático falhar, você poderá exibir um botão para permitir que os usuários façam login.
Depois de receber o resultado de OnAuthActionFinished(), você pode usar o
objeto GameServices e os Managers filhos dele para fazer chamadas de serviço do Play Games,
incluindo:
Login depois que a autorização falhar: StartAuthorizationUI()
Desbloquear conquistas: Achievements().Unlock()
Mostrar conquistas usando a IU integrada: Achievements().ShowAllUI()
Enviar a maior pontuação: Leaderboards().SubmitScore()
Sair: SignOut()
Quando terminar de usar o objeto GameServices, redefina-o ou destrua-o.
Em um nível mais detalhado:
Inicialize uma configuração de plataforma: esse objeto contém informações de inicialização específicas da plataforma. No Android, a configuração da plataforma contém a
VM Java e um ponteiro para a Activity atual:
// 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);
Construa um objeto GameServices: esse objeto é o ponto de entrada principal da
funcionalidade dos serviços relacionados a jogos do Google Play. As instâncias de GameServices são criadas
com GameServices::Builder.
Na maioria das implementações, um objeto GameServices vai persistir pelo mesmo tempo que
o ambiente C. Não é preciso reinicializar quando a
Activity do Android é pausada e retomada.
// 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);
Use as classes Manager para gerenciar o objeto GameServices. Os Managers são acessados de uma instância de GameServices e agrupam as funcionalidades relacionadas. Exemplos deles incluem os Managers Achievement e Leaderboard. Eles não contêm estado visível para o usuário por si só. Os Managers são retornados por referência, e a instância
GameServices que os contém controla o ciclo de vida deles. Seu cliente nunca deve manter uma referência ao Manager. Em vez disso, ele precisa manter a
instância de GameServices.
Os Managers retornam dados via objetos do tipo valor imutáveis. Esses valores refletem uma visualização consistente dos dados subjacentes no momento em que a consulta foi feita.
// Submit a high scoregame_services_->Leaderboards().SubmitScore(leaderboard_id,score);// Show the default Achievements UIgame_services_->Achievements().ShowAllUI();
Quando você terminar de usar o objeto GameServices, limpe-o chamando
reset() no unique_ptr a que ele pertence ou deixando que o
unique_ptr o destrua automaticamente ao sair do escopo.
Modelo de encadeamento
A não ser que informado de outra forma, todos os métodos GameServices e Manager têm
implementações assíncronas e seguras para linhas de execução. Eles podem ser chamados em qualquer linha de execução sem bloqueio externo e serão executados em uma ordem consistente com a sequência de invocação.
Métodos de acesso (os que leem estado) possuem duas variações principais. O primeiro
tipo de método (com nomes como FetchProperty()) fornece de forma assíncrona os resultados
para um callback fornecido. O segundo (com nomes como
FetchPropertyBlocking()) retorna de forma síncrona os resultados para a linha de execução
que o chamou.
Todos os retornos de chamada de usuário são invocados em um encadeamento de retorno de chamada dedicado. Essa linha de execução é potencialmente distinta de qualquer conceito de plataforma de uma "linha de execução principal" ou "linha de execução de IU". Também é importante garantir que os callbacks de usuário sejam executados rapidamente. Uma linha de execução de callback parada pode causar problemas visíveis ao usuário, como o atraso na conclusão de uma solicitação de logout.
Informações específicas da plataforma
Para começar a usar o SDK C++ do Play Games no Android, consulte o
guia de início rápido.
Leia mais
Leia a documentação de classe que acompanha o SDK C++ dos serviços relacionados a jogos do Google Play para ver mais detalhes e conferir os exemplos que demonstram como usar o SDK.
O conteúdo e os exemplos de código nesta página estão sujeitos às licenças descritas na Licença de conteúdo. Java e OpenJDK são marcas registradas da Oracle e/ou suas afiliadas.
Última atualização 2025-07-26 UTC.
[[["Fácil de entender","easyToUnderstand","thumb-up"],["Meu problema foi resolvido","solvedMyProblem","thumb-up"],["Outro","otherUp","thumb-up"]],[["Não contém as informações de que eu preciso","missingTheInformationINeed","thumb-down"],["Muito complicado / etapas demais","tooComplicatedTooManySteps","thumb-down"],["Desatualizado","outOfDate","thumb-down"],["Problema na tradução","translationIssue","thumb-down"],["Problema com as amostras / o código","samplesCodeIssue","thumb-down"],["Outro","otherDown","thumb-down"]],["Última atualização 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)."]]
