Esegui l'autenticazione utilizzando i servizi per i giochi di Google Play con C++

Puoi utilizzare i servizi per i giochi di Google Play per consentire ai giocatori di accedere a un gioco per Android creato su Firebase e scritto in C++. Per utilizzare l'accesso ai servizi per i giochi di Google Play con Firebase, devi prima consentire al giocatore di accedere con Google Play Games e richiedere un codice di autorizzazione OAuth 2.0. Quindi, passa il codice di autorizzazione a PlayGamesAuthProvider per generare una credenziale Firebase, che puoi utilizzare per l'autenticazione con Firebase.

Prima di iniziare

Prima di poter utilizzare Firebase Authentication, devi:

  • Registrare il tuo progetto C++ e configurarlo in modo che utilizzi Firebase.

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

  • Aggiungere l'Firebase C++ SDK al tuo progetto C++.

Tieni presente che l'aggiunta di Firebase al tuo progetto C++ comporta attività sia nella Firebase console sia nel progetto C++ aperto (ad esempio, scarichi i file di configurazione di Firebase dalla console, quindi li sposti nel progetto C++).

Configurare il progetto Firebase

  1. Specifica la fingerprint SHA-1 della tua app, se non l'hai già fatto.

    1. Nella console Firebase, vai alla scheda Impostazioni > Generale.

    2. Scorri verso il basso fino alla scheda Le tue app , seleziona la tua app per Android e aggiungi la fingerprint SHA-1 nel campo Impronte digitali del certificato SHA.

    Puoi ottenere l'hash SHA del certificato di firma con il comando gradle signingReport: 

    ./gradlew signingReport

    Per informazioni dettagliate su come ottenere la fingerprint SHA della tua app, consulta Autenticare il client.

  2. Attiva Google Play Games come provider di accesso:

    1. Nella console Firebase, vai a Sicurezza > Autenticazione.

    2. Genera e ottieni l'ID client e il client secret del server web del tuo progetto:

      1. Nella scheda Metodo di accesso, attiva il provider di accesso Google.

      2. Copia l'ID client e il client secret del server web dal provider di accesso Google.

    3. Nella scheda Metodo di accesso , attiva il provider di accesso Play Games e specifica l'ID client e il client secret del server web del tuo progetto, che hai ottenuto nel passaggio precedente.

Configurare Play Games services con le informazioni dell'app Firebase

  1. In the Google Play Console, apri la tua Google Play app o creane una.

  2. Nella sezione Fai crescere, fai clic su Play Games services > Configurazione e gestione > Configurazione.

  3. Fai clic su Sì, il gioco utilizza già API di Google, seleziona il tuo progetto Firebase dall'elenco e poi fai clic su Utilizza.

  4. Nella pagina di configurazione Play Games services, fai clic su Aggiungi credenziale.

    1. Seleziona il tipo Server di gioco.
    2. Nel campo Client OAuth, seleziona l'ID client web del tuo progetto. Assicurati che sia lo stesso ID client che hai specificato quando hai attivato Play Games l'accesso.
    3. Salva le modifiche.

  5. Sempre nella pagina di configurazione Play Games services, fai di nuovo clic su Aggiungi credenziale.

    1. Seleziona il tipo Android.
    2. Nel campo Client OAuth, seleziona l'ID client Android del tuo progetto. (Se non vedi l'ID client Android, assicurati di aver impostato la fingerprint SHA-1 del tuo gioco nella console Firebase.)
    3. Salva le modifiche.

  6. Nella pagina Tester, aggiungi gli indirizzi email di tutti gli utenti che devono essere in grado di accedere al tuo gioco prima che tu lo rilasci sul Play Store.

Integrare l'accesso a Play Giochi nel gioco

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

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 a Google.

Per aggiungere l'accesso a Play Games al tuo gioco utilizzando l'SDK C++ per Accedi con Google:

  1. Clona o scarica il repository del plug-in Unity per l'accesso a Google, 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++ per l'accesso a Google nel file make del codice nativo del tuo gioco:

    CMake

    Nel file CMakeLists.txt di primo livello:

    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 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. Poi, includi il componente helper Java, richiesto dall'SDK C++.

    Per farlo, nel file build.gradle a livello di progetto, aggiungi la directory di output della build dell'SDK come repository locale:

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

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

    dependencies {
    implementation 'com.google.android.gms:play-services-auth:21.6.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 in modo che utilizzi l'accesso a Play Games e recuperi un codice di autorizzazione 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 consentire al giocatore di accedere a Play Giochi:

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

    Quando il futuro restituito da SignIn() viene risolto, puoi ottenere il codice di autorizzazione 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();
    }
}

Autenticarsi con Firebase

Dopo che il giocatore ha eseguito l'accesso con Play Giochi, puoi utilizzare il codice di autorizzazione per autenticarti con Firebase.

  1. Dopo che il giocatore ha eseguito l'accesso correttamente utilizzando Play Giochi, ottieni un codice di autorizzazione per il suo account.

  2. Quindi, scambia il codice di autorizzazione dei servizi per i giochi di Play con una credenziale Firebase e utilizza la credenziale Firebase per autenticare il giocatore:

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

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

    In alternativa, se il tuo programma è basato sugli eventi, potresti preferire registrare un callback sul futuro.

Registrare un callback su un futuro

Alcuni programmi hanno funzioni 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 è basato sugli eventi, potresti preferire registrare le funzioni di callback. Una funzione di callback 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::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
 Se preferisci, la funzione di callback può anche essere una lambda. 
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);
}

Passaggi successivi

Dopo che un utente ha eseguito l'accesso per la prima volta, viene creato un nuovo account utente collegato al suo ID Play Giochi. Questo nuovo account viene memorizzato come parte del tuo progetto Firebase e può essere utilizzato per identificare un utente in ogni app del tuo progetto.

Nel gioco, puoi ottenere l'UID Firebase dell'utente dall'oggetto 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();
}

Nelle regole di sicurezza di Firebase Realtime Database e Cloud Storage, puoi ottenere l'ID utente univoco dell'utente che ha eseguito l'accesso dalla variabile auth e utilizzarlo per controllare i dati a cui un utente può accedere.

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

Per disconnettere un utente, chiama SignOut():

auth->SignOut();