Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Uwierzytelniaj za pomocą usług gier Google Play z C++

Usługi gier Google Play umożliwiają logowanie graczy w grze na Androida utworzonej w Firebase i napisanej w C++. Aby korzystać z logowania w usługach gier Google Play za pomocą Firebase, najpierw zaloguj gracza w usługach gier Google Play i poproś o kod autoryzacji OAuth 2.0. Następnie przekaż kod autoryzacji do PlayGamesAuthProvider, aby wygenerować dane logowania Firebase, których możesz użyć do uwierzytelnienia w Firebase.

Zanim zaczniesz

Zanim zaczniesz korzystać z Firebase Authentication, musisz:

zarejestrować projekt C++ i skonfigurować go pod kątem używania Firebase.

Jeśli projekt C++ korzysta już z Firebase, jest on już zarejestrowany i skonfigurowany pod kątem Firebase.
dodać pakiet Firebase C++ SDK do projektu C++.

Pamiętaj, że dodanie Firebase do projektu C++ wymaga wykonania zadań zarówno w Firebase konsoli Firebase, jak i w otwartym projekcie C++ (np. pobierasz pliki konfiguracyjne Firebase z konsoli, a następnie przenosisz je do projektu C++).

Konfigurowanie projektu w Firebase

Jeśli nie masz jeszcze odcisku cyfrowego SHA-1 aplikacji, podaj go.
1. W konsoli Firebase otwórz ustawienia Ustawienia > Ogólne tab.
2. Przewiń w dół do karty Twoje aplikacje , wybierz aplikację na Androida i dodaj odcisk cyfrowy SHA-1 w polu Odciski cyfrowe certyfikatu SHA.
Hash SHA certyfikatu podpisywania możesz uzyskać za pomocą polecenia gradle signingReport:
```
./gradlew signingReport
```
Więcej informacji o tym, jak uzyskać odcisk cyfrowy SHA aplikacji, znajdziesz w artykule Uwierzytelnianie klienta.
Włącz Google Play Games jako dostawcę logowania:
1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.
2. Wygeneruj i uzyskaj identyfikator klienta serwera WWW oraz tajny klucz klienta projektu:
  1. Na karcie Metoda logowania włącz dostawcę logowania Google.
  2. Skopiuj identyfikator klienta serwera WWW i tajny klucz klienta od dostawcy Logowania przez Google Google.
3. Na karcie Metoda logowania włącz dostawcę logowania Play Games i podaj identyfikator klienta serwera WWW oraz tajny klucz klienta projektu, które zostały uzyskane w poprzednim kroku.

Konfigurowanie Play Games services za pomocą informacji o aplikacji w Firebase

W Konsoli otwórz aplikację lub utwórz nową.Google PlayGoogle Play
W sekcji Rozwój kliknij Play Games services > Konfiguracja i zarządzanie > Konfiguracja.
Kliknij Tak, w mojej grze używam już interfejsów API Google, wybierz projekt Firebase z listy, a następnie kliknij Użyj.
Na stronie konfiguracji Play Games services kliknij Dodaj dane logowania.
1. Wybierz typ Serwer gry.
2. W polu Klient OAuth wybierz identyfikator klienta internetowego projektu. Upewnij się, że jest to ten sam identyfikator klienta, który został podany podczas włączania Play Games logowania.
3. Zapisz zmiany.
Na stronie konfiguracji Play Games services kliknij ponownie Dodaj dane logowania.
1. Wybierz typ Android.
2. W polu Klient OAuth wybierz identyfikator klienta Androida projektu. (Jeśli nie widzisz identyfikatora klienta Androida, sprawdź, czy masz ustawiony odcisk cyfrowy SHA-1 gry w konsoli Firebase).
3. Zapisz zmiany.
Na stronie Testerzy dodaj adresy e-mail wszystkich użytkowników, którzy muszą mieć możliwość zalogowania się w Twojej grze, zanim opublikujesz ją w Play Store.

Integrowanie logowania w usługach gier Play z grą

Zanim gracze będą mogli logować się w Twojej grze, musisz zintegrować logowanie w usługach gier Google Play.

Najłatwiejszym i zalecanym sposobem dodania obsługi logowania w Grach Play do projektu aplikacji na Androida jest użycie pakietu Google Sign-in C++ SDK.

Aby dodać logowanie w usługach gier Play do gry za pomocą pakietu Google Sign-in C++ SDK:

Sklonuj lub pobierz repozytorium wtyczki Google Sign-in Unity, które zawiera też pakiet C++ SDK.
Skompiluj projekt znajdujący się w katalogu staging/native/, używając Android Studio lub gradlew build.

Kompilacja kopiuje dane wyjściowe do katalogu o nazwie google-signin-cpp.

Dołącz pakiet Google Sign-in C++ SDK do pliku make kodu natywnego gry:

CMake

W pliku CMakeLists.txt najwyższego poziomu:

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

W pliku 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)

Następnie dołącz komponent pomocniczy Java, który jest wymagany przez pakiet C++ SDK.

Aby to zrobić, w pliku build.gradle na poziomie projektu dodaj katalog wyjściowy kompilacji pakietu SDK jako lokalne repozytorium:

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

W pliku build.gradle na poziomie modułu zadeklaruj komponent pomocniczy jako zależność:

dependencies {
    implementation 'com.google.android.gms:play-services-auth:21.5.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')
}

Następnie w grze skonfiguruj obiekt GoogleSignIn tak, aby używał logowania w usługach gier Play i pobierał kod autoryzacji serwera:

#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);

Na koniec wywołaj SignIn(), aby zalogować gracza w usługach gier Play:

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

Gdy przyszłość zwrócona przez SignIn() zostanie rozwiązana, możesz uzyskać kod autoryzacji serwera z wyniku:

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

Uwierzytelnianie w Firebase

Gdy gracz zaloguje się w usługach gier Play, możesz użyć kodu autoryzacji do uwierzytelnienia w Firebase.

Gdy gracz pomyślnie zaloguje się w usługach gier Play, uzyskaj kod autoryzacji dla jego konta.

Następnie wymień kod autoryzacji z usług gier Play na dane logowania Firebase i użyj ich do uwierzytelnienia gracza:

firebase::auth::Credential credential =
    firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

Jeśli program ma pętlę aktualizacji, która jest wykonywana regularnie (np. 30 lub 60 razy na sekundę), możesz sprawdzać wyniki raz na aktualizację za pomocą 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());
  }
}

Jeśli program jest oparty na zdarzeniach, możesz zarejestrować wywołanie zwrotne w przyszłości.

Rejestrowanie wywołania zwrotnego w przyszłości

Niektóre programy mają funkcje Update, które są wywoływane 30 lub 60 razy na sekundę. Na przykład wiele gier korzysta z tego modelu. Te programy mogą wywoływać funkcje LastResult, aby odpytywać wywołania asynchroniczne. Jeśli jednak program jest oparty na zdarzeniach, możesz zarejestrować funkcje wywołania zwrotnego. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu przyszłości.

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

Jeśli wolisz, funkcja wywołania zwrotnego może być też wyrażeniem lambda.

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

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z jego identyfikatorem w usługach gier Play. To nowe konto jest przechowywane jako część projektu w Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie.

W grze możesz uzyskać identyfikator UID Firebase użytkownika z obiektu firebase::auth::User:

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

W regułach bezpieczeństwa bazy danych czasu rzeczywistego Firebase i Cloud Storage możesz uzyskać unikalny identyfikator użytkownika zalogowanego z zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.

Aby uzyskać informacje o graczu w usługach gier Play lub uzyskać dostęp do usług gier Play, użyj interfejsów API udostępnianych przez pakiet C++ SDK dla usług gier Google Play.

Aby wylogować użytkownika, wywołaj SignOut():

auth->SignOut();