Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

S'authentifier à l'aide des services de jeux Google Play avec C ++

Vous pouvez utiliser les services Google Play Jeux pour connecter des joueurs à un jeu Android basé sur Firebase et écrit en C ++. Pour utiliser les services Google Play Jeux, connectez-vous avec Firebase, commencez par vous connecter au lecteur avec Google Play Games et demandez un code d'authentification OAuth 2.0 lorsque vous le faites. Ensuite, transmettez le code d'authentification à PlayGamesAuthProvider pour générer des informations d'identification Firebase, que vous pouvez utiliser pour vous authentifier avec Firebase.

Avant que tu commences

Avant de pouvoir utiliser l' authentification Firebase , vous devez:

  • Enregistrez votre projet C ++ et configurez-le pour utiliser Firebase.

    Si votre projet C ++ utilise déjà Firebase, il est déjà enregistré et configuré pour Firebase.

  • Ajoutez le SDK Firebase C ++ à votre projet C ++.

Notez que l'ajout de Firebase à votre projet C ++ implique des tâches à la fois dans la console Firebase et dans votre projet C ++ ouvert (par exemple, vous téléchargez les fichiers de configuration Firebase à partir de la console, puis les déplacez dans votre projet C ++).

Configurez votre projet Firebase

  1. Si vous ne l'avez pas déjà fait, définissez l'empreinte digitale SHA-1 de votre jeu dans la page Paramètres de la console Firebase.

    Vous pouvez obtenir le hachage SHA de votre certificat de signature avec la commande gradle signingReport :

    ./gradlew signingReport

  2. Activez Google Play Jeux en tant que fournisseur de connexion:

    1. Trouvez l'ID client du serveur Web et le secret client de votre projet. L'ID client du serveur Web identifie votre projet Firebase auprès des serveurs d'authentification Google Play.

      Pour trouver ces valeurs:

      1. Ouvrez votre projet Firebase sur la page d'informations d'identification de la console des API Google .
      2. Dans la section ID client OAuth 2.0 , ouvrez la page de détails du client Web (créé automatiquement par le service Google) . Cette page répertorie l'ID client et le secret de votre serveur Web.
    2. Ensuite, dans la console Firebase , ouvrez la section Authentification .

    3. Dans l'onglet Méthode de connexion, activez le fournisseur de connexion Play Jeux . Vous devrez spécifier l'ID client et le secret client du serveur Web de votre projet, que vous avez obtenus à partir de la console des API.

  1. Dans la console Google Play , ouvrez votre application ou créez-en une.

  2. Dans la section Grow, cliquez sur Play Games Services> Setup & Management> Configuration .

  3. Cliquez sur Oui, mon jeu utilise déjà les API Google , sélectionnez le nom de votre projet Firebase dans la liste, puis cliquez sur Utiliser .

  4. Sur la page de configuration de Play Games Services, cliquez sur Ajouter des informations d'identification .

    1. Sélectionnez le type de serveur de jeu .
    2. Dans le champ client OAuth , sélectionnez l'ID client Web de votre projet. Assurez-vous qu'il s'agit du même ID client que vous avez spécifié lorsque vous avez activé la connexion à Play Jeux.
    3. Enregistrez vos modifications.
  5. Toujours sur la page de configuration de Play Games Services, cliquez à nouveau sur Ajouter des informations d'identification .

    1. Sélectionnez le type Android .
    2. Dans le champ client OAuth , sélectionnez l'ID client Android de votre projet. (Si vous ne voyez pas votre ID client Android, assurez-vous de définir l'empreinte digitale SHA-1 de votre jeu dans la console Firebase.)
    3. Enregistrez vos modifications.
  6. Sur la page Testeurs , ajoutez les adresses e-mail de tous les utilisateurs qui doivent pouvoir se connecter à votre jeu avant de le publier sur le Play Store.

Intégrez la connexion Play Jeux à votre jeu

Avant de pouvoir connecter des joueurs à votre jeu, vous devez intégrer la connexion à Google Play Jeux.

Le moyen le plus simple et recommandé d'ajouter la prise en charge de la connexion Play Jeux à un projet Android C ++ consiste à utiliser le SDK C ++ Google Sign-in .

Pour ajouter une connexion Play Jeux à votre jeu à l'aide du SDK C ++ Google Sign-in, procédez comme suit:

  1. Clonez ou téléchargez le référentiel de plug-ins Google Sign-in Unity , qui contient également le SDK C ++.

  2. Générez le projet contenu dans le répertoire staging/native/ , soit à l'aide d'Android Studio ou de gradlew build .

    La compilation copie sa sortie dans un répertoire nommé google-signin-cpp .

  3. Incluez le SDK C ++ Google Sign-in dans le fichier de création de code natif de votre jeu:

    CMake

    Dans votre fichier CMakeLists.txt niveau 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

    Dans votre fichier 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. Ensuite, incluez le composant d'assistance Java, qui est requis par le SDK C ++.

    Pour ce faire, dans votre fichier build.gradle niveau du build.gradle , ajoutez le répertoire de sortie de build du SDK en tant que référentiel local:

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

    Et, dans votre fichier build.gradle niveau du build.gradle , déclarez le composant d'assistance en tant que dépendance:

    dependencies {
        implementation 'com.google.android.gms:play-services-auth:19.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. Ensuite, dans votre jeu, configurez un objet GoogleSignIn pour utiliser la GoogleSignIn à Play Jeux et pour récupérer un code d'authentification du serveur:

    #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. Enfin, appelez SignIn() pour connecter le joueur à Play Jeux:

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

    Lorsque le futur renvoyé par SignIn() résout, vous pouvez obtenir le code d'authentification du serveur à partir du résultat:

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

S'authentifier avec Firebase

Une fois que le joueur s'est connecté à Play Jeux, vous pouvez utiliser le code d'authentification pour vous authentifier auprès de Firebase.

  1. Une fois que le joueur s'est connecté avec succès à Play Jeux, obtenez un code d'authentification pour le compte du joueur.

  2. Ensuite, échangez le code d'authentification des services Play Jeux contre un identifiant Firebase et utilisez les identifiants Firebase pour authentifier le lecteur:

    firebase::auth::Credential credential =
        firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Si votre programme a une boucle de mise à jour qui s'exécute régulièrement (disons à 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par mise à jour avec 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, si votre programme est axé sur les événements, vous préférerez peut-être enregistrer un rappel sur le futur .

Enregistrer un rappel sur un avenir

Certains programmes ont des fonctions de Update qui sont appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler les fonctions LastResult pour interroger les appels asynchrones. Cependant, si votre programme est piloté par les événements, vous préférerez peut-être enregistrer des fonctions de rappel. Une fonction de rappel est appelée à la fin du 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);
}
La fonction de rappel peut également être un lambda, si vous préférez.
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);
}

Prochaines étapes

Lorsqu'un utilisateur se connecte pour la première fois, un nouveau compte utilisateur est créé et lié à son ID Play Jeux. Ce nouveau compte est stocké dans le cadre de votre projet Firebase et peut être utilisé pour identifier un utilisateur dans chaque application de votre projet.

Dans votre jeu, vous pouvez obtenir l'UID Firebase de l'utilisateur à partir de l'objet 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();
}

Dans vos règles de sécurité Firebase Realtime Database et Cloud Storage, vous pouvez obtenir l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Pour obtenir des informations sur le joueur Play Jeux d'un utilisateur ou pour accéder aux services Play Jeux, utilisez les API fournies par le SDK C ++ des services Google Play Jeux .

Pour déconnecter un utilisateur, appelez SignOut() :

auth->SignOut();