Autenticazione utilizzando i servizi di giochi di Google Play con C++

Puoi utilizzare i servizi Google Play Games per accedere ai giocatori a un gioco Android basato su Firebase e scritto in C++. Per utilizzare i servizi Google Play Games, accedi con Firebase, accedi innanzitutto al player con Google Play Games e, quando lo fai, 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.

Prima di iniziare

Prima di poter utilizzare l'autenticazione Firebase , devi:

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

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

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

Tieni presente che l'aggiunta di Firebase al tuo progetto C++ comporta attività sia nella console Firebase che nel tuo progetto C++ aperto (ad esempio, scarichi i file di configurazione Firebase dalla console, quindi li sposti nel tuo 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 Firebase.

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

    ./gradlew signingReport

  2. Abilita Google Play Giochi come fornitore di accesso:

    1. Nella console Firebase, apri la sezione Autenticazione .

    2. Genera e ottieni l'ID client e il segreto client del server Web del tuo progetto:

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

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

    3. Nella scheda Metodo di accesso , abilita il provider di accesso di Play Giochi e specifica l'ID client del server web e il segreto client del tuo progetto, che hai ottenuto nell'ultimo passaggio.

Configura i servizi Play Games con le informazioni dell'app Firebase

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

  2. Nella sezione Crescita , fai clic su Servizi per i giochi di Play > Configurazione e gestione > Configurazione .

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

  4. Nella pagina di configurazione dei servizi per i giochi di Play, fai clic su Aggiungi credenziale .

    1. Seleziona il tipo di server di gioco .
    2. Nel campo Client OAuth , seleziona l'ID client Web del tuo progetto. Assicurati che questo sia lo stesso ID client che hai specificato quando hai abilitato l'accesso a Play Giochi.
    3. Salva le modifiche.
  5. Sempre nella pagina di configurazione dei servizi Play Games, fai nuovamente clic su Aggiungi credenziale .

    1. Seleziona il tipo di Android .
    2. Nel campo Client OAuth , seleziona l'ID client Android del tuo progetto. (Se non vedi il tuo ID client Android, assicurati di impostare l'impronta digitale SHA-1 del gioco nella console Firebase.)
    3. Salva le modifiche.
  6. Nella pagina Tester , aggiungi gli indirizzi email di tutti gli utenti che devono poter accedere al tuo gioco prima di rilasciarlo nel Play Store.

Integra l'accesso a Play Games nel tuo gioco

Prima di poter far accedere i 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++ consiste nell'utilizzare l' SDK C++ di Google Sign-in .

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

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

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

    La build copia il proprio output in una directory denominata google-signin-cpp .

  3. Includi l'SDK C++ di Google Sign-in 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 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, includi il componente helper Java, richiesto dall'SDK C++.

    Per fare ciò, 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.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. Quindi, nel tuo gioco, configura un oggetto GoogleSignIn per utilizzare l'accesso a Play Games e per 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 far accedere il giocatore a Play Games:

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

    Quando il Future restituito da SignIn() si risolve, puoi 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();
        }
    }
    

Autenticarsi con Firebase

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

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

  2. Quindi, scambia il codice di autenticazione dai servizi Play Games 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 ciclo di aggiornamento che viene eseguito regolarmente (diciamo 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());
      }
    }

    Oppure, se il tuo programma è basato sugli eventi, potresti preferire registrare una richiamata sul Future .

Registra una richiamata su un Future

Alcuni programmi dispongono di funzioni Update richiamate 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 su eventi, potresti preferire registrare le funzioni di callback. Una funzione di callback viene richiamata al completamento del 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);
}
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::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);
}

Prossimi passi

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

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

Nel tuo Firebase Realtime Database e nelle regole di sicurezza Cloud Storage, puoi ottenere l'ID utente univoco dell'utente che ha effettuato l'accesso dalla variabile auth e utilizzarlo per controllare a quali dati può accedere un utente.

Per ottenere informazioni sui giocatori di 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, chiama SignOut() :

auth->SignOut();