Premiers pas avec les services de jeux Play pour C++

Le SDK des services de jeux Google Play pour C++ fournit une API C++ à utiliser avec les services de jeux Google Play. Il est destiné aux développeurs qui possèdent déjà une implémentation C++ de leur jeu.

Actuellement, le SDK implémente les services suivants:

  • Autorisation
  • Réussites
  • Classements
  • Événements
  • Jeux enregistrés
  • Connexions à proximité (Android uniquement)
  • Statistiques du joueur

Concepts

En règle générale, utilisez le SDK en procédant comme suit:

  1. Configurez la plate-forme Android.
  2. Utilisez un GameServices::Builder pour configurer et construire un objet GameServices. L'objet GameServices tente automatiquement de se connecter et renvoie le résultat via un rappel OnAuthActionFinished(). Notez le résultat renvoyé par le rappel. Si la tentative de connexion automatique a échoué, vous pouvez afficher un bouton permettant aux utilisateurs de se connecter.
  3. Après avoir reçu le résultat OnAuthActionFinished(), vous pouvez utiliser l'objet GameServices et ses administrateurs enfants pour effectuer des appels aux services Play Jeux, y compris:

    • Connexion (après échec de l'autorisation) : StartAuthorizationUI()
    • Débloquez des réussites: Achievements().Unlock()
    • Afficher les réussites à l'aide de l'interface utilisateur intégrée: Achievements().ShowAllUI()
    • Envoyez un score élevé: Leaderboards().SubmitScore()
    • Déconnexion: SignOut()
  4. Lorsque vous avez terminé d'utiliser l'objet GameServices, réinitialisez-le ou détruisez-le.

À un niveau plus détaillé:

  1. Initialiser une configuration de plate-forme: il s'agit d'un objet contenant des informations d'initialisation spécifiques à une plate-forme. Sur Android, la configuration de la plate-forme contient la VM Java et un pointeur vers le Activity actuel :

    // In android_main(), create a platform configuration
    // and bind the object activity.
    // Alternately, attach the activity in JNI_Onload().
    gpg::AndroidPlatformConfiguration platform_configuration;
    platform_configuration.SetActivity(state->activity->clazz);
    
  2. Créez un objet GameServices. Il s'agit du point d'entrée principal de la fonctionnalité des services de jeux Google Play. Les instances GameServices sont créées avec GameServices::Builder.

    Dans la plupart des implémentations, un objet GameServices donné est conservé aussi longtemps que votre environnement C. Vous n'avez pas besoin de le réinitialiser lorsque votre Activity Android s'interrompt, puis reprend.

    // Creates a GameServices object that has lambda callbacks.
    game_services_ = gpg::GameServices::Builder()
            .SetDefaultOnLog(gpg::LogLevel::VERBOSE)
            .SetOnAuthActionStarted([started_callback](gpg::AuthOperation op) {
                is_auth_in_progress_ = true;
                started_callback(op);
            })
            .SetOnAuthActionFinished([finished_callback](gpg::AuthOperation op,
                                                         gpg::AuthStatus status) {
                LOGI("Sign in finished with a result of %d", status);
                is_auth_in_progress_ = false;
                finished_callback(op, status);
            })
            .Create(pc);
    
  3. Utilisez les classes du gestionnaire pour gérer votre objet GameServices. Les gestionnaires sont accessibles depuis une instance GameServices et regroupent les fonctionnalités liées. Il peut s'agir, par exemple, des gestionnaires de réussites ou de classements. Ils ne contiennent pas eux-mêmes d'état visible par l'utilisateur. Les gestionnaires sont renvoyés par référence, et l'instance GameServices qui les contient contrôle leur cycle de vie. Votre client ne doit jamais conserver une référence administrateur. Au lieu de cela, votre client doit conserver l'instance GameServices.

    Les gestionnaires renvoient des données via des objets de type valeur immuable. Ces valeurs reflètent une vue cohérente des données sous-jacentes au moment où la requête a été effectuée.

    // Submit a high score
    game_services_->Leaderboards().SubmitScore(leaderboard_id, score);
    
    // Show the default Achievements UI
    game_services_->Achievements().ShowAllUI();
    
  4. Lorsque vous avez terminé d'utiliser l'objet GameServices, effectuez un nettoyage en appelant reset() sur le unique_ptr qui lui appartient ou en laissant automatiquement unique_ptr le détruire lorsqu'il sort de son champ d'application.

Modèle de threading

Sauf indication contraire, toutes les méthodes GameServices et Manager disposent d'implémentations asynchrones sécurisées. Elles peuvent être appelées sur n'importe quel thread sans verrouillage externe et s'exécutent dans un ordre cohérent avec leur ordre d'invocation.

Les méthodes d'accesseur (celles qui lisent l'état) sont disponibles en deux variantes majeures. Le premier type de méthode (avec des noms tels que FetchProperty()) fournit ses résultats de manière asynchrone à un rappel fourni ; le second (avec des noms tels que FetchPropertyBlocking()) renvoie les résultats de manière synchrone au thread appelant.

// Blocking callback
gpg::AchievementManager::FetchAllResponse fetchResponse =
        game_services_->Achievements().FetchAllBlocking(std::chrono::milliseconds(1000));

// Non-blocking callback
game_services_->Achievements().FetchAll(gpg::DataSource::CACHE_OR_NETWORK,
    [] (gpg::AchievementManager::FetchAllResponse response) {
    LogI("Achievement response status: %d", response.status);});

Tous les rappels d'utilisateurs sont appelés sur un thread de rappel dédié. Ce thread est potentiellement différent de tout concept de plate-forme de "thread principal" ou de "thread UI". Vous devez également vous assurer que les rappels des utilisateurs s'exécutent rapidement. Un thread de rappel bloqué peut entraîner des problèmes visibles par l'utilisateur (par exemple, un retard de traitement d'une requête de déconnexion).

Informations spécifiques à la plate-forme

Pour commencer à utiliser le SDK Play Jeux C++ sur Android, passez au guide de démarrage rapide.

Complément d'informations

Pour en savoir plus, consultez la documentation du cours sur le SDK C++ des services de jeux Google Play, et consultez les exemples d'utilisation du SDK.

Si votre jeu utilise un serveur backend, consultez la page Activer l'accès côté serveur aux services de jeux Google Play.