Diese Seite wurde von der Cloud Translation API übersetzt.

Mit den Google Play-Spieldiensten mit C++ authentifizieren

Du kannst Google Play-Spieldienste verwenden, um Spieler für ein Android-Spiel anzumelden die auf Firebase basieren und in C++ geschrieben sind. So meldest du dich mit den Google Play-Spieldiensten an mit Firebase aktiviert haben, melden Sie sich im Player mit Google Play Spiele an und fordern Sie OAuth 2.0-Authentifizierungscode an. Übergeben Sie dann den Autorisierungscode an PlayGamesAuthProvider zum Generieren von Firebase-Anmeldedaten, mit denen du sich bei Firebase zu authentifizieren.

Hinweis

Vor der Verwendung Firebase Authentication, sind folgende Schritte erforderlich:

Registrieren Sie Ihr C++-Projekt und konfigurieren Sie es für die Verwendung von Firebase.

Wenn in Ihrem C++-Projekt bereits Firebase verwendet wird, ist es bereits für Firebase registriert und konfiguriert.
Fügen Sie Ihrem C++-Projekt das Firebase C++ SDK hinzu.

Beachten Sie, dass das Hinzufügen von Firebase zu Ihrem C++-Projekt sowohl Aufgaben im Firebase-Konsole und in Ihrem offenen C++-Projekt, z. B. wenn Sie Firebase-Konfigurationsdateien aus der Console aus und verschieben Sie sie dann in Ihr C++-Projekt.

Das Firebase-Projekt einrichten

Falls noch nicht geschehen, lege den SHA-1-Fingerabdruck deines Spiels in der Seite Einstellungen der Firebase-Konsole.

Sie können den SHA-Hash Ihres Signaturzertifikats mit dem Befehl gradlesigningReport abrufen:
```
./gradlew signingReport
```
Aktivieren Sie Google Play Games als Anbieter für Anmeldungen:
1. Öffnen Sie in der Firebase-Konsole das Feld Authentication.
2. Webserver-Client-ID und -Client für Ihr Projekt generieren und abrufen Secret:
  1. Aktivieren Sie auf dem Tab Anmeldemethode die Google-Anmeldung. Dienstanbieter.
  2. Kopieren Sie die Client-ID und das Secret des Webservers vom Google-Anmeldeanbieter.
3. Aktivieren Sie auf dem Tab Anmeldemethode den Anmeldeanbieter Play Games und geben Sie die Webserver-Client-ID und den Clientschlüssel Ihres Projekts an, die Sie im letzten Schritt erhalten haben.

Play Games services mit den Informationen Ihrer Firebase-App konfigurieren

Im Google Play-Konsole, öffnen Sie die Google Play App oder erstellen Sie eine.
Klicken Sie im Bereich Wachstum auf Play Games services > Einrichtung und Verwaltung > Konfiguration.
Klicken Sie auf Ja, in meinem Spiel kommen bereits Google-APIs zum Einsatz, wählen Sie Ihr Firebase-Projekt aus der Liste aus und klicken Sie dann auf Verwenden.
Klicken Sie auf der Konfigurationsseite von Play Games services auf Anmeldedaten hinzufügen.
1. Wählen Sie den Typ Game Server (Spieleserver) aus.
2. Wählen Sie im Feld OAuth-Client die Webclient-ID Ihres Projekts aus. Seien Dies ist dieselbe Client-ID, die Sie bei der Aktivierung Play Games-Anmeldung.
3. Speichern Sie die Änderungen.
Klicken Sie auf der Konfigurationsseite von Play Games services auf Füge die Anmeldedaten noch einmal hinzu.
1. Wählen Sie den Typ Android aus.
2. Wählen Sie im Feld OAuth-Client die Android-Client-ID Ihres Projekts aus. Wird Ihre Android-Client-ID nicht angezeigt, überprüfen Sie, SHA-1-Fingerabdruck in der Firebase-Konsole.)
3. Speichern Sie die Änderungen.
Fügen Sie auf der Seite Tester die E-Mail-Adressen aller Nutzer hinzu, die in Ihrem Spiel anmelden können, bevor Sie es Play Store

Anmeldung über Play Spiele in Ihr Spiel einbinden

Bevor Sie Spieler in Ihrem Spiel anmelden können, müssen Sie die Google Play Spiele-Anmeldung einbinden.

Die einfachste und empfohlene Methode, einem C++-Android-Projekt die Unterstützung für die Anmeldung in Play-Spielen hinzuzufügen, ist die Verwendung des Google Sign-in C++ SDK.

Um die Play Spiele-Anmeldung mit dem Google Log-in C++ SDK zu deinem Spiel hinzuzufügen, führe die Folgendes:

Klonen oder laden Sie das Repository für das Google Sign-in-Unity-Plug-in herunter, das auch das C++ SDK enthält.
Erstellen Sie das im Verzeichnis staging/native/ enthaltene Projekt entweder mit Android Studio oder gradlew build

Der Build kopiert die Ausgabe in ein Verzeichnis mit dem Namen google-signin-cpp.

Fügen Sie das Google Log-in C++ SDK in die Codeerstellungsdatei Ihres Spiels ein:

CMake

In der Datei CMakeLists.txt auf oberster Ebene:

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

In der Datei 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)

Fügen Sie als Nächstes die Java-Hilfskomponente ein, die für das C++ SDK erforderlich ist.

Fügen Sie dazu in der Datei build.gradle auf Projektebene das SDK-Build-Ausgabeverzeichnis als lokales Repository hinzu:

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

Deklarieren Sie die Hilfskomponente in der Datei build.gradle auf Modulebene als Abhängigkeit:

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

Konfiguriere dann in deinem Spiel ein GoogleSignIn-Objekt für die Verwendung von Play Spiele melden Sie sich an und rufen Sie einen Server-Authentifizierungscode ab:

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

Rufen Sie abschließend SignIn() auf, um den Spieler in Google Play Spiele anzumelden:

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

Wenn die von SignIn() zurückgegebene Future abgeschlossen ist, kannst du den Serverauthentifizierungscode aus dem Ergebnis abrufen:

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

Mit Firebase authentifizieren

Nachdem sich der Spieler mit Play Spiele angemeldet hat, können Sie sich mit dem Authentifizierungscode bei Firebase authentifizieren.

Nachdem sich der Spieler bei Play Spiele angemeldet hat, fordern Sie eine Authentifizierung an. für das Konto des Spielers.

Tauschen Sie dann den Autorisierungscode der Play-Spieldienste gegen ein Firebase-Gerät aus Anmeldedaten und authentifizieren Sie den Spieler mithilfe der Firebase-Anmeldedaten:

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

Wenn Ihr Programm eine Update-Schleife hat, die regelmäßig ausgeführt wird (z. B. 30- oder 60-mal pro Sekunde), können Sie die Ergebnisse einmal pro Update mit Auth::SignInAndRetrieveDataWithCredentialLastResult prüfen:

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

Wenn Ihr Programm ereignisgesteuert ist, einen Callback im Future registrieren.

Callback für einen Future registrieren

Einige Programme haben Update-Funktionen, die 30 oder 60 Mal pro Sekunde aufgerufen werden. So folgen beispielsweise viele Spiele diesem Modell. Diese Programme können die LastResult-Funktionen aufrufen, um asynchrone Aufrufe abzufragen. Wenn Ihr Programm jedoch ereignisgesteuert ist, sollten Sie Callback-Funktionen registrieren. Nach Abschluss des Futures wird eine Callback-Funktion aufgerufen.

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

Die Rückruffunktion kann auch eine Lambda-Funktion sein.

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

Nächste Schritte

Nachdem sich ein Nutzer zum ersten Mal angemeldet hat, wird ein neues Nutzerkonto erstellt und die mit ihrer Play Spiele-ID verknüpft ist. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in allen Apps in Ihrem Projekt zu identifizieren.

In Ihrem Spiel können Sie die Firebase-UID des Nutzers über das firebase::auth::User-Objekt abrufen:

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

In Ihren Firebase Realtime Database- und Cloud Storage-Sicherheitsregeln können Sie die eindeutige Nutzer-ID des angemeldeten Nutzers aus der Variablen auth abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

Wenn Sie die Play Spiele-Spielerinformationen eines Nutzers abrufen oder auf Play Spiele-Dienste zugreifen möchten, verwenden Sie die APIs des C++ SDK für die Google Play-Spieldienste.

Um einen Nutzer abzumelden, rufen Sie SignOut() auf:

auth->SignOut();