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

Oyuncuların Firebase üzerinde oluşturulmuş ve C++ ile yazılmış bir Android oyununda oturum açmasını sağlamak için Google Play Oyunlar hizmetlerini kullanabilirsiniz. Google Play Oyunlar hizmetlerini kullanmak için Firebase ile oturum açın, öncelikle oynatıcıda Google Play Oyunlar ile oturum açın ve bunu yaparken bir OAuth 2.0 kimlik doğrulama kodu isteyin. Ardından, Firebase ile kimlik doğrulamak için kullanabileceğiniz bir Firebase kimlik bilgisi oluşturmak üzere kimlik doğrulama kodunu PlayGamesAuthProvider iletin.

Sen başlamadan önce

Firebase Authentication'ı kullanabilmeniz için ş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ış demektir.

  • Firebase C++ SDK'sını 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 indirir ve ardından bunları C++ projenize taşırsınız).

Firebase projenizi ayarlayın

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

    İmza sertifikanızın SHA karmasını signingReport komutuyla alabilirsiniz:

    ./gradlew signingReport

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

    1. Firebase konsolunda Kimlik Doğrulama bölümünü açın.

    2. Projenizin web sunucusu istemci kimliğini ve istemci sırrını oluşturun ve edinin:

      1. Oturum açma yöntemi sekmesinde Google oturum açma sağlayıcısını etkinleştirin.

      2. Web sunucusu istemci kimliğini ve sırrını Google oturum açma sağlayıcısından kopyalayın.

    3. Oturum açma yöntemi sekmesinde Play Games oturum açma sağlayıcısını etkinleştirin ve son adımda aldığınız projenizin web sunucusu istemci kimliğini ve istemci sırrını belirtin.

Play Oyunlar hizmetlerini Firebase uygulama bilgilerinizle yapılandırma

  1. Google Play Console'da Google Play uygulamanızı açın veya bir tane oluşturun.

  2. Büyüme bölümünde Play Games 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 istemcisi kimliğini seçin. Bunun, Play Oyunlar'da oturum açmayı etkinleştirdiğinizde belirttiğiniz istemci kimliğinin aynı olduğundan emin olun.
    3. Değişikliklerinizi kaydedin.
  5. Hâlâ Play Oyunlar hizmetleri yapılandırma sayfasındayken Kimlik Bilgisi Ekle'yi tekrar 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 Kullanıcıları sayfasında, oyunu Play Store'da yayınlamadan önce oyununuzda oturum açabilmesi gereken tüm kullanıcıların e-posta adreslerini ekleyin.

Play Oyunlar oturum açma işlemini oyununuza entegre edin

Oyuncuların oyununuzla oturum açmasından önce Google Play Oyunlar oturum açma özelliğini entegre etmeniz gerekir.

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

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

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

  2. staging/native/ dizininde bulunan projeyi Android Studio veya gradlew build kullanarak oluşturun.

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

  3. Google Oturum Açma C++ SDK'sını oyununuzun yerel kod yapım 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-yapısı

    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. Daha sonra, C++ SDK'sının gerektirdiği Java yardımcı bileşenini ekleyin.

    Bunu yapmak için proje düzeyindeki build.gradle dosyanıza SDK derleme çıktı dizinini yerel 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 bağımlılık olarak bildirin:

    dependencies {
        implementation 'com.google.android.gms:play-services-auth:20.7.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. Ardından oyununuzda, Play Games'te oturum açmayı kullanmak ve 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, oyuncunun Play Games'te oturum açmasını sağlamak için SignIn() öğesini çağırın:

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

    SignIn() tarafından döndürülen Gelecek çözümlendiğinde, sunucu kimlik doğrulama kodunu sonuçtan 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ğrulama

Oyuncu Play Oyunlar'da oturum açtıktan sonra Firebase'de kimlik doğrulaması yapmak için kimlik doğrulama kodunu kullanabilirsiniz.

  1. Oyuncu Play Games'i kullanarak başarıyla oturum açtıktan sonra, oyuncunun hesabı için bir kimlik doğrulama kodu alın.

  2. Ardından Play Oyunlar hizmetlerindeki kimlik doğrulama kodunu Firebase kimlik bilgisi ile değiştirin ve oynatıcının 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::AuthResult> result =
        auth->SignInAndRetrieveDataWithCredential(credential);
    
  3. Programınızın düzenli olarak çalışan bir güncelleme döngüsü varsa (saniyede 30 veya 60 kez diyelim), 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());
      }
    }
    ile sonuçları güncelleme başına bir kez kontrol edebilirsiniz.

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

Gelecekteki bir geri aramayı kaydedin

Bazı programlarda saniyede 30 veya 60 kez çağrılan Update işlevleri bulunur. Örneğin birçok oyun bu modeli takip ediyor. Bu programlar, eşzamansız çağrıları yoklamak için LastResult işlevlerini çağırabilir. Ancak programınız olay odaklıysa geri çağırma 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::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
İsterseniz geri çağırma işlevi bir lambda da olabilir.
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);
}

Sonraki adımlar

Bir kullanıcı ilk kez oturum açtıktan sonra yeni bir kullanıcı hesabı oluşturulur ve Play Games 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 UID'sini firebase::auth::User nesnesinden alabilirsiniz:

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

Firebase Gerçek Zamanlı Veritabanı ve Bulut Depolama Güvenliği Kurallarınızda, oturum açan kullanıcının benzersiz kullanıcı kimliğini auth değişkeninden alabilir ve bunu, 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'sı tarafından sağlanan API'leri kullanın.

Bir kullanıcının oturumunu kapatmak için SignOut() öğesini çağırın:

auth->SignOut();