Fazer a autenticação usando os serviços relacionados a jogos do Google Play com C++

É possível usar os serviços relacionados a jogos do Google Play para fazer login em um jogo Android criado no Firebase e escrito em C++. Para usar o login desses serviços com o Firebase, primeiro faça login do jogador no Google Play Games e solicite um código de autenticação do OAuth 2.0. Em seguida, envie esse código para PlayGamesAuthProvider a fim de gerar uma credencial do Firebase, que poderá ser usada para acessar a plataforma.

Antes de começar

Antes de usar o Firebase Authentication, é necessário:

  • Registrar seu projeto em C++ e configurá-lo para usar o Firebase

    Se o projeto já usa o Firebase, então ele já está registrado e configurado para essa plataforma.

  • No arquivo build.gradle no nível do projeto, inclua o repositório Maven do Google nas seções buildscript e allprojects.

  • Adicione o SDK do Firebase para C++ ao seu projeto nessa linguagem de programação.

A adição do Firebase ao projeto em C++ envolve tarefas no Console do Firebase e no projeto em C++ aberto (por exemplo, você faz o download dos arquivos de configuração do Firebase no console e os move para o projeto em C++).

Configurar seu projeto do Firebase

  1. Caso você ainda não tenha configurado a impressão digital SHA-1 do jogo, faça isso na página de Configurações do console do Firebase.

    É possível receber o hash SHA do certificado de assinatura com o comando signingReport do Gradle:

    ./gradlew signingReport

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

    1. Encontre o código do cliente do servidor da Web e a chave secreta do cliente referente ao seu projeto. O código do cliente do servidor da Web identifica seu projeto do Firebase para os servidores de autenticação do Google Play.

      Para encontrar esses valores:

      1. Abra o projeto do Firebase na página de credenciais do Console de APIs do Google.
      2. Na seção de códigos do cliente OAuth 2.0, abra a página de detalhes do cliente da Web (criada automaticamente pelo serviço do Google). Nessa página, há uma lista com a chave secreta e o código do cliente do servidor da Web.
    2. Em seguida, no Console do Firebase, abra a seção Autenticação.

    3. Na guia Método de login, ative o provedor de login do Play Games. Será necessário especificar o código do cliente do servidor da Web e a chave secreta do cliente referente ao seu projeto, que você localizou no console de APIs.

  1. Abra o Google Play Console e clique em Serviços relacionados a jogos.
  2. Clique em Adicionar um novo jogo. Nessa caixa de diálogo, clique em Já utilizo APIs do Google em meu jogo e clique no nome do seu projeto do Firebase na lista. Selecione uma categoria de jogo e clique em Continuar para acessar a página de detalhes do jogo.
  3. No final dessa página, verifique se todas as APIs necessárias estão ativadas.
  4. Em seguida, abra a página Apps vinculados e clique em Android. Especifique o nome do pacote do seu jogo e clique em Salvar e continuar. O console exibirá seu código do cliente do Android. Você pode ignorar esse valor.
  5. Na página Teste, coloque na lista de permissões os endereços de e-mail de qualquer usuário que precise fazer login no seu jogo antes de liberá-lo na Play Store.

Integrar o login do Play Games ao seu jogo

Antes de permitir a conexão dos jogadores, é necessário integrar o login do Google Play Games ao seu jogo.

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

Para adicionar o login do Play Games ao seu jogo com o SDK para C++ do Login do Google, siga as seguintes etapas:

  1. Clone ou faça o download do repositório de plug-ins para Unity do Login do Google, que também contém o SDK para C ++.

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

    A versão copia a saída do processo para um diretório chamado google-signin-cpp.

  3. Inclua o SDK para C++ do Login do Google no makefile 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 de ajuda do Java exigido pelo SDK para C++.

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

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

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

    dependencies {
        implementation 'com.google.android.gms:play-services-auth:18.1.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, configure no seu jogo um objeto GoogleSignIn para usar o login do 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 a classe Future retornada por SignIn() for resolvida, você receberá o código de autenticação do servidor no 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 o Firebase

Depois que o jogador fizer o login com o Play Games, você poderá usar o código desse processo para fazer a autenticação com o Firebase.

  1. Depois que o usuário fizer login usando o Play Games, você receberá 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 que será usada para autenticar o jogador:

    firebase::auth::Credential credential =
        firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Se seu programa tiver uma rotina de atualização regular, por exemplo, 30 ou 60 vezes por segundo, será possível verificar os resultados uma vez por ciclo usando Auth::SignInWithCredentialLastResult:

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

    Caso seu programa seja voltado para eventos, você poderá optar por registrar um retorno de chamada no Futuro.

Registrar um retorno de chamada no Futuro

Alguns programas têm função Update que são chamadas 30 ou 60 vezes por segundo. Muitos jogos, por exemplo, seguem esse modelo. Esses programas podem invocar as funções LastResult para pesquisar chamadas assíncronas. Caso seu programa seja baseado em eventos, pode ser preferível registrar funções de retorno de chamada. Essas funções são chamadas na conclusão da classe 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::User*> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
Se você preferir, a função de retorno de chamada também pode ser um lambda.
void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::User*> 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óximas etapas

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada ao código do Play Games. Essa nova conta é armazenada como parte do seu projeto do Firebase e pode ser usada para identificar um usuário em cada app no seu projeto.

No seu jogo, é possível receber o UID do Firebase referente ao usuário usando o objeto firebase::auth::User:

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  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, é possível usar a variável auth para acessar o código exclusivo do usuário que fez login. Use essa informação para controlar quais dados os usuários podem acessar.

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

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

auth->SignOut();