Autenticare con Google Play Games Services con C ++

Puoi utilizzare i servizi di Google Play Giochi per accedere ai giocatori a un gioco Android basato su Firebase e scritto in C ++. Per utilizzare i servizi di Google Play Games accedi con Firebase, accedi prima al lettore con Google Play Games e richiedi un codice di autenticazione OAuth 2.0. Quindi, passa il codice di autenticazione a PlayGamesAuthProvider per generare una credenziale Firebase, che puoi utilizzare per autenticarti con Firebase.

Importante: puoi utilizzare l'accesso ai servizi di Google Play Games solo su Android.

Prima di iniziare

Prima di poter utilizzare l' autenticazione Firebase , è necessario:

• Registra il tuo progetto C ++ e configuralo per usare Firebase.

  Se il tuo progetto C ++ utilizza già Firebase, è già registrato e configurato per Firebase.

• Nel tuo file build.gradle livello di build.gradle , assicurati di includere il repository Maven di Google nelle sezioni buildscript e allprojects .

• Aggiungi l' SDK C ++ di Firebase al tuo progetto C ++.

Trova le istruzioni dettagliate per queste attività di configurazione iniziale in Aggiungi Firebase al tuo progetto C ++ .

Si noti che l'aggiunta di Firebase al progetto C ++ comporta attività sia nella console Firebase che nel progetto C ++ aperto (ad esempio, scaricare i file di configurazione di Firebase dalla console, quindi spostarli nel progetto C ++).

Configura il tuo progetto Firebase

1. Se non l'hai già fatto, imposta l'impronta digitale SHA-1 del tuo gioco nella pagina Impostazioni della console di Firebase.

   È possibile ottenere l'hash SHA del certificato di firma con il comando Gradle signingReport :

   ./gradlew signingReport

2. Abilita Google Play Games come provider di accesso:

   1. Trova l'ID client del server web del progetto e il segreto client. L'ID client del server Web identifica il tuo progetto Firebase sui server di autenticazione di Google Play.

      Per trovare questi valori:

      1. Apri il tuo progetto Firebase nella pagina delle credenziali della console delle API di Google .
      2. Nella sezione ID client OAuth 2.0 , apri la pagina dei dettagli del client Web (creato automaticamente dal servizio Google) . Questa pagina elenca l'ID client e il segreto del server Web.

   2. Quindi, nella console di Firebase , apri la sezione Autenticazione .

   3. Nella scheda Metodo di accesso , abilitare il provider di accesso a Play Games . Sarà necessario specificare l'ID client del server Web del progetto e il segreto client, ottenuti dalla console delle API.

Collega il tuo progetto Firebase al tuo account editore Play

1. Apri la console di Google Play e fai clic su Servizi giochi .
2. Fai clic su Aggiungi nuovo gioco . Nella finestra di dialogo del nuovo gioco, fai clic su Utilizzo già API di Google nel mio gioco e fai clic sul nome del tuo progetto Firebase nell'elenco. Seleziona una categoria di gioco, quindi fai clic su Continua per accedere alla pagina Dettagli gioco.
3. Alla fine della pagina Dettagli gioco, assicurati che tutte le API richieste siano abilitate.
4. Quindi, apri la pagina App collegate e fai clic su Android . Specifica il nome del pacchetto del gioco e fai clic su Salva e continua . La console visualizzerà il tuo ID client Android. Puoi ignorare questo valore.
5. Nella pagina Test , autorizza gli indirizzi email di tutti gli utenti che devono essere in grado di accedere al tuo gioco prima di rilasciarlo sul Play Store.

Integra l'accesso a Play Games nel tuo gioco

Prima di poter accedere ai giocatori al tuo gioco, devi integrare l'accesso a Google Play Games.

Il modo più semplice e consigliato per aggiungere il supporto per l'accesso a Play Games a un progetto Android C ++ è utilizzare l' SDK C ++ per l'accesso di Google .

Per aggiungere l'accesso a Play Games al gioco utilizzando l'SDK C ++ per l'accesso di Google, procedi come segue:

1. Clonare o scaricare il repository di plug-in Unity di Google Sign-in , che contiene anche l'SDK C ++.

2. Crea il progetto contenuto nella directory staging/native/ , utilizzando Android Studio o gradlew build .

   La build copia l'output in una directory denominata google-signin-cpp .

3. Includi l'SDK C ++ di accesso Google nel file di creazione del codice nativo del gioco:

   CMake

   Nel tuo file CMakeLists.txt livello CMakeLists.txt :

   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

   Nel tuo file 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. Successivamente, includere il componente helper Java, richiesto dall'SDK C ++.

   Per fare ciò, nel file build.gradle livello di build.gradle , aggiungere la directory di output della build SDK come repository locale:

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

   E, nel tuo file build.gradle livello di build.gradle , dichiara il componente helper come dipendenza:

    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. Quindi, nel gioco, configura un oggetto GoogleSignIn per utilizzare l'accesso a Play Games e recuperare un codice di autenticazione del server:

    #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. Infine, chiama SignIn() per accedere al giocatore su Play Games:

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

   Quando il futuro restituito da SignIn() risolve, è possibile ottenere il codice di autenticazione del server dal risultato:

    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();
       }
   }
    

Autenticare con Firebase

Dopo che il giocatore ha effettuato l'accesso con Play Games, è possibile utilizzare il codice di autenticazione per autenticarsi con Firebase.

1. Dopo che il giocatore ha effettuato correttamente l'accesso utilizzando Play Games, ottieni un codice di autenticazione per l'account del giocatore.

2. Quindi, scambia il codice di autenticazione dai servizi di Play Games con una credenziale di Firebase e usa le credenziali di Firebase per autenticare il giocatore:

    firebase::auth::Credential credential =
       firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
   firebase::Future<firebase::auth::User*> result =
       auth->SignInWithCredential(credential);
    

3. Se il tuo programma ha un ciclo di aggiornamento che viene eseguito regolarmente (diciamo 30 o 60 volte al secondo), puoi controllare i risultati una volta per aggiornamento con 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());
     }
   }

   Oppure, se il tuo programma è guidato da eventi, potresti preferire registrare una richiamata sul futuro .

Registra una richiamata su un futuro

Alcuni programmi hanno funzioni di Update che vengono chiamate 30 o 60 volte al secondo. Ad esempio, molti giochi seguono questo modello. Questi programmi possono chiamare le funzioni LastResult per eseguire il polling delle chiamate asincrone. Tuttavia, se il tuo programma è guidato da eventi, potresti preferire registrare le funzioni di callback. Una funzione di richiamata viene chiamata al completamento del futuro.

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);
}

La funzione di callback può anche essere una lambda, se preferisci.

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);
}

Prossimi passi

Dopo che un utente accede per la prima volta, viene creato un nuovo account utente e collegato al proprio ID Play Games. Questo nuovo account viene archiviato come parte del progetto Firebase e può essere utilizzato per identificare un utente in ogni app del progetto.

Nel tuo gioco, puoi ottenere l'UID Firebase firebase::auth::User dall'oggetto 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();
}
 

Nelle regole di sicurezza di Firebase Realtime Database e Cloud Storage, è possibile ottenere l'ID utente univoco dell'utente connesso dalla variabile auth e utilizzarlo per controllare a quali dati può accedere un utente.

Per ottenere le informazioni sul giocatore Play Games di un utente o per accedere ai servizi Play Games, utilizza le API fornite dall'SDK C ++ dei servizi Google Play Games .

Per disconnettere un utente, chiamare SignOut() :

 auth->SignOut();