Ta strona została przetłumaczona przez Cloud Translation API.

Uwierzytelniaj za pomocą usług gier Google Play z C++
Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Możesz używać usług Gier Google Play do logowania graczy w grach na Androida stworzonych w Firebase i napisanych w języku C++. Aby zalogować się w usługach Gier Google Play za pomocą Firebase, zaloguj się w odtwarzaczu w Grach Google Play i poproś o użyj kodu uwierzytelniającego OAuth 2.0. Następnie przekaż kod autoryzacji do PlayGamesAuthProvider, aby wygenerować dane logowania Firebase, których możesz użyć do: uwierzytelniać się w Firebase.

Zanim zaczniesz

Zanim będzie można użyć Firebase Authentication musisz:

Zarejestruj swój projekt C++ i skonfiguruj go pod kątem korzystania z Firebase.

Jeśli Twój projekt w C++ korzysta już z Firebase, to jest już zarejestrowany skonfigurowane na potrzeby Firebase.
Dodaj pakiet SDK Firebase C++ do projektu C++.

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

Skonfiguruj projekt Firebase

Ustaw odcisk cyfrowy SHA-1 swojej gry w Strona Ustawienia konsoli Firebase.

Za pomocą Gradle możesz uzyskać hasz SHA Twojego certyfikatu podpisywania Polecenie signingReport:
```
./gradlew signingReport
```
Włącz Google Play Games jako dostawcę logowania:
1. W konsoli Firebase otwórz Authentication.
2. Generowanie i uzyskiwanie identyfikatora klienta i klienta serwera WWW projektu obiekt tajny:
  1. Na karcie Metoda logowania włącz logowanie przez Google. dostawcy usług.
  2. Skopiuj identyfikator klienta i tajny klucz serwera WWW z sekcji logowania Google dostawcy usług.
3. Na karcie Metoda logowania włącz Play Games. dostawcy logowania i określ identyfikator klienta serwera WWW swojego projektu (tajny klucz klienta) uzyskany w ostatnim kroku.

Skonfiguruj Play Games services, używając informacji z aplikacji Firebase

W Konsola Google Play, otwórz aplikację Google Play lub utwórz aplikację.
W sekcji Rozwój kliknij Play Games services Konfiguracja Zarządzanie > Konfiguracja.
Kliknij Tak, moja gra już używa interfejsów API Google i wybierz Firebase. projekt na liście i kliknij Użyj.
Na stronie konfiguracji Play Games services kliknij Add Credential (Dodaj dane logowania).
1. Wybierz typ Serwer gry.
2. W polu Klient OAuth wybierz identyfikator klienta internetowego swojego projektu. Bądź upewnij się, że jest to identyfikator klienta podany podczas włączania opcji Play Games – logowanie.
3. Zapisz zmiany.
Pozostając na stronie konfiguracji Play Games services, kliknij Ponownie Dodaj dane logowania.
1. Wybierz typ Androida.
2. W polu Klient OAuth wybierz identyfikator klienta Androida dla swojego projektu. (Jeśli nie widzisz identyfikatora klienta Androida, upewnij się, że masz ustawiony Odcisk cyfrowy SHA-1 w konsoli Firebase).
3. Zapisz zmiany.
Na stronie Testerzy dodaj adresy e-mail wszystkich użytkowników, którzy że będziesz mieć możliwość zalogowania się w grze przed opublikowaniem jej Play Store

Integrowanie logowania w Grach Play z grą

Aby móc logować graczy w swojej grze, musisz zintegrować Google Play Logowanie w grach.

Najłatwiejszy i zalecany sposób dodawania obsługi logowania w Grach Play do języka C++ W projekcie na Androida należy używać pakietu SDK C++ do logowania przez Google.

Aby dodać do gry logowanie przez Gry Play za pomocą pakietu SDK C++ logowania przez Google, wykonaj :

Skopiuj lub pobierz repozytorium wtyczki Google Sign-in Unity. który zawiera też pakiet SDK C++.
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 SDK C++ do logowania przez Google w natywnym pliku tworzenia kodu 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 dodaj komponent pomocniczy Java, który jest wymagany przez pakiet SDK C++.

Aby to zrobić, dodaj w pliku build.gradle na poziomie projektu kompilację pakietu SDK jako repozytorium lokalne:

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.3.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')
}

Następnie w swojej grze skonfiguruj obiekt GoogleSignIn, aby korzystać z Gier Play zaloguj się i pobierz kod uwierzytelniania 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(), by zalogować gracza w Grach Play:

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

Gdy odpowiedź przyszła zwrócona przez SignIn() zostanie rozpoznana, możesz uzyskać uwierzytelnianie serwera kod 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();
    }
}

Uwierzytelnij za pomocą Firebase

Gdy gracz zaloguje się w Grach Play, możesz użyć kodu autoryzacji, uwierzytelniać się w Firebase.

Gdy gracz zaloguje się za pomocą Gier Play, otrzymaj uwierzytelnianie dla konta gracza.

Następnie wymień kod autoryzacji z usług Gier Play na potrzeby Firebase dane logowania i użyj danych logowania Firebase, aby uwierzytelnić gracza:

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

Jeśli Twój program ma pętlę aktualizacji, która działa regularnie (np. przy 30 lub 60 sekundzie) razy na sekundę), możesz sprawdzić wyniki raz na każdą aktualizację, 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());
  }
}

A jeśli Twój program jest oparty na zdarzeniach, możesz preferować zarejestruj się na rozmowę w przyszłości.

Rejestrowanie oddzwonienia 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ć LastResult do sondowania wywołań asynchronicznych. Jeśli jednak Twój program jest oparty na zdarzeniach, możesz zarejestrować funkcje wywołań zwrotnych. Funkcja wywołania zwrotnego jest wywoływana po zakończeniu okresu przyszłego.

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 też być lambdą.

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, tworzone jest nowe konto użytkownika. powiązane z identyfikatorem Gier Play. To nowe konto jest przechowywane w ramach projektu Firebase i możesz go użyć do identyfikacji użytkownika w każdej aplikacji w projektach AI.

W grze możesz uzyskać identyfikator Firebase UID użytkownika w aplikacji firebase::auth::User obiekt:

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 Bazie danych czasu rzeczywistego Firebase i Regułach zabezpieczeń Cloud Storage możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i użyj go do kontrolować dostęp użytkownika do danych.

Aby uzyskać informacje o użytkowniku w Grach Play lub uzyskać dostęp do usług Gier Play: używać interfejsów API udostępnianych przez pakiet SDK C++ usług gier Google Play,

Aby wylogować użytkownika, zadzwoń pod numer SignOut():

auth->SignOut();