Autenticar usando os serviços relacionados a jogos do Google Play com C++

Você pode usar os serviços do Google Play Games para fazer login de jogadores em um jogo Android criado no Firebase e escrito em C++. Para usar o login dos serviços Google Play Games com o Firebase, primeiro faça login no player com o Google Play Games e solicite um código de autenticação OAuth 2.0 ao fazer isso. Em seguida, passe o código de autenticação para PlayGamesAuthProvider para gerar uma credencial do Firebase, que você pode usar para autenticar com o Firebase.

Antes de você começar

Antes de usar o Firebase Authentication , você precisa:

  • Registre seu projeto C++ e configure-o para usar o Firebase.

    Se o seu projeto C++ já usa o Firebase, ele já está registrado e configurado para o Firebase.

  • Adicione o SDK do Firebase para C++ ao seu projeto C++.

Observe que adicionar o Firebase ao seu projeto C++ envolve tarefas no console do Firebase e no seu projeto C++ aberto (por exemplo, você baixa os arquivos de configuração do Firebase do console e os move para o seu projeto C++).

Configure seu projeto do Firebase

  1. Se ainda não o fez, defina a impressão digital SHA-1 do seu jogo na página Configurações do console do Firebase.

    Você pode obter o hash SHA do seu certificado de assinatura com o comando gradle signingReport :

    ./gradlew signingReport

  2. Ative o Google Play Games como provedor de login:

    1. No console do Firebase, abra a seção Autenticação .

    2. Gere e obtenha o ID do cliente do servidor web e o segredo do cliente do seu projeto:

      1. Na guia Método de login , habilite o provedor de login do Google .

      2. Copie o ID do cliente do servidor Web e o segredo do provedor de login do Google .

    3. Na guia Método de login , ative o provedor de login do Play Games e especifique o ID do cliente do servidor Web e o segredo do cliente do seu projeto, obtidos na última etapa.

Configure os serviços do Play Games com as informações do seu aplicativo Firebase

  1. No Google Play Console , abra seu aplicativo Google Play ou crie um.

  2. Na seção Crescer , clique em Serviços do Play Games > Configuração e gerenciamento > Configuração .

  3. Clique em Sim, meu jogo já usa APIs do Google , selecione seu projeto do Firebase na lista e clique em Usar .

  4. Na página de configuração dos serviços do Play Games, clique em Adicionar credencial .

    1. Selecione o tipo de servidor de jogo .
    2. No campo Cliente OAuth , selecione o ID do cliente web do seu projeto. Certifique-se de que este seja o mesmo ID de cliente especificado quando ativou o login no Play Games.
    3. Salve suas alterações.

  5. Ainda na página de configuração dos serviços do Play Games, clique novamente em Adicionar credencial .

    1. Selecione o tipo de Android .
    2. No campo Cliente OAuth , selecione o ID do cliente Android do seu projeto. (Se você não vir seu ID de cliente Android, defina a impressão digital SHA-1 do jogo no console do Firebase.)
    3. Salve suas alterações.

  6. Na página Testadores , adicione os endereços de e-mail de todos os usuários que precisam fazer login no jogo antes de lançá-lo na Play Store.

Integre o login do Play Games ao seu jogo

Antes de poder conectar jogadores ao seu jogo, você deve integrar o login do Google Play Games.

A maneira mais fácil e recomendada de adicionar suporte para login do Play Games a um projeto C++ Android é usar o SDK C++ do Login do Google .

Para adicionar o login do Play Games ao seu jogo usando o SDK C++ do Login do Google, faça o seguinte:

  1. Clone ou baixe o repositório de plug-ins do Google Sign-in Unity , que também contém o SDK C++.

  2. Crie o projeto contido no diretório staging/native/ usando Android Studio ou gradlew build .

    A compilação copia sua saída para um diretório chamado google-signin-cpp .

  3. Inclua o SDK C++ do Login do Google no arquivo make do código nativo do seu jogo:

    CMake

    No seu arquivo CMakeLists.txt de nível superior:

    set(GSI_PACKAGE_DIR "/path/to/google-signin-cpp")
    
add_library(lib-google-signin-cpp STATIC IMPORTED)
set_target_properties(lib-google-signin-cpp PROPERTIES IMPORTED_LOCATION
    ${GSI_PACKAGE_DIR}/lib/${ANDROID_ABI}/libgoogle-signin-cpp.a )

    ...
    
target_link_libraries(
    ...
    lib-google-signin-cpp)

    ndk-build

    No seu arquivo Android.mk :

    include $(CLEAR_VARS)
LOCAL_MODULE := google-signin-cpp
GSI_SDK_DIR := /path/to/google-signin-cpp
LOCAL_SRC_FILES := $(GSI_SDK_DIR)/lib/$(TARGET_ARCH_ABI)/libgoogle-signin-cpp.a
LOCAL_EXPORT_C_INCLUDES := $(GSI_SDK_DIR)/include
include $(PREBUILT_STATIC_LIBRARY)

  4. Em seguida, inclua o componente auxiliar Java, que é exigido pelo SDK C++.

    Para fazer isso, em seu arquivo build.gradle no nível do projeto, adicione o diretório de saída de compilação do SDK como um repositório local:

    allprojects {
    repositories {
        // ...
        flatDir {
            dirs 'path/to/google-signin-cpp'
        }
    }
}

    E, em seu arquivo build.gradle de nível de módulo, declare o componente auxiliar como uma dependência:

    dependencies {
    implementation 'com.google.android.gms:play-services-auth:21.0.0'
    // Depend on the AAR built with the Google Sign-in SDK in order to add
    // the Java helper classes, which are used by the C++ library.
    compile(name:'google-signin-cpp-release', ext:'aar')
}

  5. Em seguida, no jogo, configure um objeto GoogleSignIn para usar o login no Play Games e recuperar um código de autenticação do servidor:

    #include "google_signin.h"
#include "future.h"

using namespace google::signin;

// ...

GoogleSignIn::Configuration config = {};
config.web_client_id = "YOUR_WEB_CLIENT_ID_HERE";
config.request_id_token = false;
config.use_game_signin = true;
config.request_auth_code = true;

GoogleSignIn gsi = GoogleSignIn(GetActivity(), GetJavaVM());
gsi.Configure(config);

  6. Por fim, chame SignIn() para fazer login do jogador no Play Games:

    Future<GoogleSignIn::SignInResult> &future = gsi.SignIn();

    Quando o Future retornado por SignIn() for resolvido, você poderá obter o código de autenticação do servidor a partir do resultado:

    if (!future.Pending()) {
    const GoogleSignIn::StatusCode status =
            static_cast<GoogleSignIn::StatusCode>(future.Status());
    if (status == GoogleSignIn::kStatusCodeSuccess) {
        // Player successfully signed in to Google Play! Get auth code to
        //   pass to Firebase
        const GoogleSignIn::SignInResult result =
                static_cast<GoogleSignIn::SignInResult>(future.Result());
        const char* server_auth_code = result.User.GetServerAuthCode();
    }
}

Autenticar com Firebase

Depois que o jogador fizer login no Play Games, você poderá usar o código de autenticação para se autenticar no Firebase.

  1. Depois que o jogador fizer login usando o Play Games, obtenha um código de autenticação para a conta do jogador.

  2. Em seguida, troque o código de autenticação dos serviços do Play Games por uma credencial do Firebase e use a credencial do Firebase para autenticar o jogador:

    firebase::auth::Credential credential =
    firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

  3. Se o seu programa tiver um loop de atualização executado regularmente (digamos, 30 ou 60 vezes por segundo), você poderá verificar os resultados uma vez por atualização com Auth::SignInAndRetrieveDataWithCredentialLastResult :

    firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredentialLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for `%s`\n",
           auth_result.user.display_name().c_str());
  } else {
    printf("Sign in failed with error '%s'\n", result.error_message());
  }
}

    Ou, se o seu programa for orientado a eventos, você pode preferir registrar um retorno de chamada no Future .

Registre um retorno de chamada em um Future

Alguns programas possuem funções Update que são chamadas 30 ou 60 vezes por segundo. Por exemplo, muitos jogos seguem este modelo. Esses programas podem chamar as funções LastResult para sondar chamadas assíncronas. No entanto, se o seu programa for orientado a eventos, você pode preferir registrar funções de retorno de chamada. Uma função de retorno de chamada é chamada após a conclusão do Future.
void OnCreateCallback(const firebase::Future<firebase::auth::User*>& result,
                      void* user_data) {
  // The callback is called when the Future enters the `complete` state.
  assert(result.status() == firebase::kFutureStatusComplete);

  // Use `user_data` to pass-in program context, if you like.
  MyProgramContext* program_context = static_cast<MyProgramContext*>(user_data);

  // Important to handle both success and failure situations.
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());

    // Perform other actions on User, if you like.
    firebase::auth::User::UserProfile profile;
    profile.display_name = program_context->display_name;
    user->UpdateUserProfile(profile);

  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

void CreateUser(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
A função de retorno de chamada também pode ser um lambda, se preferir.
void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // The lambda has the same signature as the callback function.
  result.OnCompletion(
      [](const firebase::Future<firebase::auth::User*>& result,
         void* user_data) {
        // `user_data` is the same as &my_program_context, below.
        // Note that we can't capture this value in the [] because std::function
        // is not supported by our minimum compiler spec (which is pre C++11).
        MyProgramContext* program_context =
            static_cast<MyProgramContext*>(user_data);

        // Process create user result...
        (void)program_context;
      },
      &my_program_context);
}

Próximos passos

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada ao ID do Play Games. Essa nova conta é armazenada como parte do seu projeto do Firebase e pode ser usada para identificar um usuário em todos os aplicativos do seu projeto.

No seu jogo, você pode obter o UID do Firebase do usuário no objeto firebase::auth::User :

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string playerName = user.displayName();

  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

Nas regras de segurança do Firebase Realtime Database e do Cloud Storage, você pode obter o ID de usuário exclusivo do usuário conectado na variável auth e usá-lo para controlar quais dados um usuário pode acessar.

Para obter informações de jogador do Play Games de um usuário ou acessar os serviços do Play Games, use as APIs fornecidas pelo SDK C++ dos serviços do Google Play Games .

Para desconectar um usuário, chame SignOut() :

auth->SignOut();