Google Play Oyun Hizmetlerini C++ ile Kullanarak Kimlik Doğrulama

Oyuncuların Firebase üzerine kurulu ve C++ ile yazılmış bir Android oyununda oturum açmak için Google Play Oyunlar hizmetlerini kullanabilirsiniz. Google Play Oyunlar hizmetlerinde Firebase ile oturum açmak için önce oynatıcıda Google Play Oyunlar ile oturum açın ve bunu yaptığınızda bir OAuth 2.0 kimlik doğrulama kodu isteyin. Ardından, Firebase ile kimlik doğrulaması yapmak için kullanabileceğiniz bir Firebase kimlik bilgisi oluşturmak için yetkilendirme kodunu PlayGamesAuthProvider iletin.

Sen başlamadan önce

Firebase Authentication'ı kullanmadan önce şunları yapmanız gerekir:

  • C++ projenizi kaydedin ve Firebase'i kullanacak şekilde yapılandırın.

    C++ projeniz zaten Firebase kullanıyorsa, Firebase için zaten kayıtlı ve yapılandırılmıştır.

  • Firebase C++ SDK'yı C++ projenize ekleyin.

Firebase'i C++ projenize eklemenin hem Firebase konsolundaki hem de açık C++ projenizdeki görevleri içerdiğini unutmayın (örneğin, Firebase yapılandırma dosyalarını konsoldan indirirsiniz, ardından bunları C++ projenize taşırsınız).

Firebase projenizi kurun

  1. Henüz yapmadıysanız, Firebase konsolunun Ayarlar sayfasında oyununuzun SHA-1 parmak izini ayarlayın.

    İmzalama sertifikanızın SHA karmasını gradle signingReport komutuyla alabilirsiniz:

    ./gradlew signingReport

  2. Google Play Oyunlar'ı oturum açma sağlayıcısı olarak etkinleştirin:

    1. Projenizin web sunucusu istemci kimliğini ve istemci sırrını bulun. Web sunucusu istemci kimliği, Firebase projenizi Google Play yetkilendirme sunucularına tanımlar.

      Bu değerleri bulmak için:

      1. Firebase projenizi Google API konsolu kimlik bilgileri sayfasında açın.
      2. OAuth 2.0 istemci kimlikleri bölümünde, Web istemcisi (Google Hizmeti tarafından otomatik olarak oluşturulur) ayrıntılar sayfasını açın. Bu sayfa, web sunucusu istemci kimliğinizi ve sırrınızı listeler.

    2. Ardından, Firebase konsolunda Kimlik Doğrulama bölümünü açın.

    3. Oturum açma yöntemi sekmesinde Play Oyunlar oturum açma sağlayıcısını etkinleştirin. API konsolundan aldığınız projenizin web sunucusu istemci kimliğini ve istemci sırrını belirtmeniz gerekecektir.

Firebase uygulama bilgilerinizle Play Oyunlar hizmetlerini yapılandırın

  1. Google Play Konsolunda , Google Play uygulamanızı açın veya bir tane oluşturun.

  2. Büyüme bölümünde, Play Oyunlar hizmetleri > Kurulum ve Yönetim > Yapılandırma'yı tıklayın.

  3. Evet, oyunum zaten Google API'lerini kullanıyor 'u tıklayın, listeden Firebase projenizi seçin ve ardından Kullan 'ı tıklayın.

  4. Play Oyunlar hizmetleri yapılandırma sayfasında, Kimlik Bilgisi Ekle 'yi tıklayın.

    1. Oyun sunucusu türünü seçin.
    2. OAuth istemcisi alanında projenizin web istemci kimliğini seçin. Bunun Play Oyunlar oturum açmayı etkinleştirdiğinizde belirttiğiniz istemci kimliğiyle aynı olduğundan emin olun.
    3. Değişikliklerinizi kaydedin.

  5. Yine Play Oyunlar hizmetleri yapılandırma sayfasında, tekrar Kimlik Bilgisi Ekle'yi tıklayın.

    1. Android türünü seçin.
    2. OAuth istemcisi alanında projenizin Android istemci kimliğini seçin. (Android istemci kimliğinizi görmüyorsanız oyununuzun SHA-1 parmak izini Firebase konsolunda ayarladığınızdan emin olun.)
    3. Değişikliklerinizi kaydedin.

  6. Testçiler sayfasında, oyununuzu Play Store'da yayınlamadan önce oturum açabilmesi gereken tüm kullanıcıların e-posta adreslerini ekleyin.

Play Oyunlar oturum açma özelliğini oyununuza entegre edin

Oyuncuların oyununuzda oturum açmadan önce Google Play Oyunlar oturum açma özelliğini entegre etmeniz gerekir.

Bir C++ Android projesine Play Oyunlar oturum açma desteği eklemenin en kolay ve önerilen yolu, Google Oturum Açma C++ SDK'sını kullanmaktır.

Google Sign-in C++ SDK'sını kullanarak oyununuza Play Oyunlar oturum açma özelliğini eklemek için aşağıdakileri yapın:

  1. C++ SDK'yı da içeren Google Sign-in Unity eklenti deposunu klonlayın veya indirin.

  2. Staging staging/native/ dizininde bulunan projeyi, Android Studio veya gradlew build kullanarak derleyin.

    Derleme, çıktısını google-signin-cpp adlı bir dizine kopyalar.

  3. Google Sign-in C++ SDK'sını oyununuzun yerel kod oluşturma dosyasına ekleyin:

    CMake

    Üst düzey CMakeLists.txt dosyanızda:

    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

    Android.mk dosyanızda:

    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. Ardından, C++ SDK için gerekli olan Java yardımcı bileşenini ekleyin.

    Bunu yapmak için proje düzeyindeki build.gradle dosyanıza SDK derleme çıktı dizinini yerel bir depo olarak ekleyin:

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

    Ve modül düzeyindeki build.gradle dosyanızda yardımcı bileşeni bir bağımlılık olarak bildirin:

    dependencies {
    implementation 'com.google.android.gms:play-services-auth:20.4.1'
    // 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. Ardından, oyununuzda Play Oyunlar oturum açmayı kullanmak ve bir sunucu kimlik doğrulama kodunu almak için bir GoogleSignIn nesnesi yapılandırın:

    #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. Son olarak, oyuncuyu Play Oyunlar'da oturum açmak için SignIn() 'i arayın:

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

    SignIn() tarafından döndürülen Gelecek çözümlendiğinde, sonuçtan sunucu kimlik doğrulama kodunu alabilirsiniz:

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

Firebase ile kimlik doğrulaması yapın

Oyuncu Play Oyunlar ile oturum açtıktan sonra, Firebase ile kimlik doğrulaması yapmak için yetkilendirme kodunu kullanabilirsiniz.

  1. Oyuncu, Play Oyunlar'da başarıyla oturum açtıktan sonra, oyuncunun hesabı için bir yetkilendirme kodu alın.

  2. Ardından, Play Oyunlar hizmetlerinden gelen kimlik doğrulama kodunu bir Firebase kimlik bilgisi ile değiştirin ve oyuncunun kimliğini doğrulamak için Firebase kimlik bilgisini kullanın:

    firebase::auth::Credential credential =
    firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
firebase::Future<firebase::auth::User*> result =
    auth->SignInWithCredential(credential);

  3. Programınızda düzenli olarak çalışan bir güncelleme döngüsü varsa (saniyede 30 veya 60 kez diyelim), sonuçları her güncellemede bir kez 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());
  }
}
    ile kontrol edebilirsiniz.

    Veya programınız olay odaklıysa, Future'da bir geri arama kaydetmeyi tercih edebilirsiniz.

Bir Gelecek için bir geri arama kaydedin

Bazı programlar, saniyede 30 veya 60 kez çağrılan Update işlevlerine sahiptir. Örneğin birçok oyun bu modeli takip ediyor. Bu programlar, asenkron çağrıları yoklamak için LastResult işlevlerini çağırabilir. Ancak, programınız olay odaklıysa, geri arama işlevlerini kaydetmeyi tercih edebilirsiniz. Geleceğin tamamlanması üzerine bir geri arama işlevi çağrılır.
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);
}
İsterseniz geri arama işlevi bir lambda olabilir.
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);
}

Sonraki adımlar

Bir kullanıcı ilk kez oturum açtıktan sonra yeni bir kullanıcı hesabı oluşturulur ve Play Oyunlar Kimliğine bağlanır. Bu yeni hesap, Firebase projenizin bir parçası olarak depolanır ve projenizdeki her uygulamada bir kullanıcıyı tanımlamak için kullanılabilir.

Oyununuzda, kullanıcının firebase::auth::User nesnesinden alabilirsiniz:

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

Firebase Gerçek Zamanlı Veritabanınız ve Bulut Depolama Güvenlik Kurallarınızda, oturum açmış kullanıcının benzersiz kullanıcı kimliğini auth değişkeninden alabilir ve bunu bir kullanıcının hangi verilere erişebileceğini kontrol etmek için kullanabilirsiniz.

Bir kullanıcının Play Oyunlar oynatıcı bilgilerini almak veya Play Oyunlar hizmetlerine erişmek için Google Play Oyunlar hizmetleri C++ SDK tarafından sağlanan API'leri kullanın.

Bir kullanıcının oturumunu kapatmak için SignOut() 'u arayın:

auth->SignOut();