O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

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

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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 do 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 seu projeto C++ já usa o Firebase, ele já está registrado e configurado para o Firebase.

  • Adicione o SDK C++ do Firebase 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ê faz o download dos arquivos de configuração do Firebase do console e os move para o seu projeto C++).

Configurar 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 Firebase.

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

    ./gradlew signingReport

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

    1. Encontre o ID do cliente do servidor da Web e o segredo do cliente do seu projeto. O ID 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 seu projeto do Firebase na página de credenciais do console de APIs do Google .
      2. Na seção IDs do cliente OAuth 2.0 , abra a página de detalhes do cliente Web (criado automaticamente pelo serviço do Google) . Esta página lista o ID e o segredo do cliente do seu servidor 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 . Você precisará especificar o ID do cliente do servidor da Web e o segredo do cliente do seu projeto, obtidos no console de APIs.

Configure os serviços do Play Games com as informações do seu app 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 que você especificou quando ativou o login do 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, certifique-se de definir a impressão digital SHA-1 do seu 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 seu jogo antes de lançá-lo na Play Store.

Integre o login do Play Games ao seu jogo

Antes de poder fazer login de jogadores em 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 em um projeto Android C++ é usar o SDK C++ de login do Google .

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

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

  2. Compile o projeto contido no diretório staging/native/ usando o 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++ de login do Google no arquivo make do código nativo do seu jogo:

    CMake

    No 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:20.4.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, em seu jogo, configure 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 conectar o jogador ao Play Games:

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

    Quando o Future retornado por SignIn() resolvido, você poderá obter o código de autenticação do servidor 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 o 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::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Se o seu programa tiver um loop de atualização que é executado regularmente (digamos, 30 ou 60 vezes por segundo), você pode verificar os resultados uma vez por atualização com 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());
      }
    }

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

Registrar um retorno de chamada em um Future

Alguns programas têm funções de Update que são chamadas 30 ou 60 vezes por segundo. Por exemplo, muitos jogos seguem esse modelo. Esses programas podem chamar as funções LastResult para pesquisar 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::User*> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
A função callback também pode ser um lambda, se você preferir.
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óximos passos

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada à 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 != 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, você pode obter o ID de usuário exclusivo do usuário conectado na variável de auth e usá-lo para controlar quais dados um usuário pode acessar.

Para obter as informações do 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();