Google 致力于为黑人社区推动种族平等。查看具体举措

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

Vous pouvez utiliser les services Google Play Games pour connecter les joueurs à un jeu Android construit 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 Jeux et demandez un code d'autorisation OAuth 2.0 lorsque vous le faites. Ensuite, passez le code auth à PlayGamesAuthProvider pour générer un titre Firebase, que vous pouvez utiliser pour authentifier avec Firebase.

Avant que tu commences

Avant de pouvoir utiliser Firebase authentification , 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.

  • Ajouter le Firebase C ++ SDK à votre projet C de.

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

Configurer votre projet Firebase

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

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

    ./gradlew signingReport

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

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

      Pour trouver ces valeurs :

      1. Ouvrez votre projet Firebase dans la console API Google les informations d' identification page.
      2. Dans la section ID client OAuth 2.0, ouvrez le client Web (auto créé par le service Google) Détails Page. Cette page répertorie l'ID client et le secret de votre serveur Web.
    2. Puis, dans la console Firebase , ouvrez la section d' authentification.

    3. Sur l'onglet Connexion méthode, activez le jeu Jeux de connexion fournisseur. 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 en créer un.

  2. Dans la section Grandissez, cliquez sur Emettre Jeux Services> Configuration et gestion> Configuration.

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

  4. Sur la page de configuration Play Games Services, cliquez sur Ajouter des titres de compétences.

    1. Sélectionnez le type de serveur de jeu.
    2. Dans le champ client OAuth, sélectionnez client Web de votre projet ID. 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 Lecture Jeux Services, cliquez sur Ajouter à nouveau des titres de compétences.

    1. Sélectionnez le type Android.
    2. Dans le champ client OAuth, sélectionnez ID client Android de votre projet. (Si vous ne voyez pas votre ID client Android, assurez-vous de définir l'empreinte 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 ont besoin d' être en mesure de vous connecter à votre jeu avant de le libérer sur le Google 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 plus simple et recommandé moyen d'ajouter un soutien pour le jeu Jeux de connexion à un projet Android C ++ est d'utiliser le signe dans Google SDK C ++ .

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

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

  2. Construire le projet contenu dans la staging/native/ en gradlew build staging/native/ répertoire, soit en utilisant Android Studio ou gradlew build .

    La construction des copies de 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 :

    Cfaire

    Dans votre haut niveau CMakeLists.txt fichier:

    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 Android.mk fichier:

    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, requis par le SDK C++.

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

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

    Et, dans votre niveau du module build.gradle fichier, déclarer le composant aide comme une dépendance:

    dependencies {
        implementation 'com.google.android.gms:play-services-auth:19.2.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, configurer un GoogleSignIn objet à utiliser la lecture Jeux de connexion et de 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 signer le joueur pour jouer Jeux:

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

    Quand l'avenir est revenu par SignIn() décide, vous pouvez obtenir le code serveur auth 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 à l'aide de Play Jeux, obtenez un code d'autorisation pour le compte du joueur.

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

    firebase::auth::Credential credential =
        firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Si votre programme est une boucle de mise à jour qui fonctionne régulièrement (disons à 30 ou 60 fois par seconde), vous pouvez vérifier les résultats une fois par 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 commandé événement, vous pouvez préférer enregistrer un rappel sur l'avenir .

Enregistrer un rappel sur un Future

Certains programmes ont Update à Update des fonctions qui sont appelées 30 ou 60 fois par seconde. Par exemple, de nombreux jeux suivent ce modèle. Ces programmes peuvent appeler les LastResult fonctions au sondage des appels asynchrones. Cependant, si votre programme est piloté par des é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 aussi ê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 identifiant 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 UID Firebase de l'utilisateur du firebase::auth::User objet:

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 votre base de données et en temps réel Firebase Cloud Storage Les règles de sécurité, vous pouvez obtenir la signature dans ID d'utilisateur unique de l' utilisateur de la auth variable et l' utiliser pour contrôler les données d' un accès utilisateur peut.

Pour obtenir une informations de joueur Jeux Jouer utilisateur ou pour accéder à des services de jeux Google Play, utilisez les API fournies par les services de Google Play Games SDK C ++ .

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

auth->SignOut();