Mit den Google Play-Spieldiensten mit C++ authentifizieren

Mit den Google Play Games-Diensten können sich Spieler in einem Android-Spiel anmelden, das auf Firebase basiert und in C++ geschrieben wurde. Wenn du die Google Play Games-Dienste für die Anmeldung mit Firebase verwenden möchtest, melde den Spieler zuerst bei Google Play Games an und fordere dabei einen OAuth 2.0-Autorisierungscode an. Übergebe den Autorisierungscode dann an PlayGamesAuthProvider, um Anmeldedaten für Firebase zu generieren, mit denen du dich bei Firebase authentifizieren kannst.

Hinweis

Bevor du Firebase Authentication, verwenden kannst, musst du Folgendes tun:

  • Registriere dein C++-Projekt und konfiguriere es für die Verwendung von Firebase.

    Wenn dein C++-Projekt bereits Firebase verwendet, ist es bereits registriert und für Firebase konfiguriert.

  • Füge deinem C++-Projekt das Firebase C++ SDK hinzu.

Das Hinzufügen von Firebase zu deinem C++-Projekt umfasst Aufgaben in der Firebase Console und in deinem geöffneten C++-Projekt. Du lädst beispielsweise Firebase-Konfigurationsdateien aus der Console herunter und verschiebst sie dann in dein C++-Projekt.

Das Firebase-Projekt einrichten

  1. Gib den SHA-1-Fingerabdruck deiner App an, falls noch nicht geschehen.

    1. Rufe in der Firebase Console die Einstellungen > Allgemein Tab auf.

    2. Scrolle nach unten zur Karte Meine Apps , wähle deine Android-App aus und füge den SHA-1-Fingerabdruck im Feld SHA-Zertifikat-Fingerabdrücke hinzu.

    Du kannst den SHA-Hash deines Signaturzertifikats mit dem Gradle-Befehl signingReport abrufen: 

    ./gradlew signingReport

    Weitere Informationen zum Abrufen des SHA-Fingerabdrucks deiner App findest du unter Client authentifizieren.

  2. Aktiviere Google Play Games als Anmeldeanbieter:

    1. Rufe in der Firebase Console Security > Authentication auf.

    2. Generiere und rufe die Webserver-Client-ID und den Clientschlüssel deines Projekts ab:

      1. Aktiviere auf dem Tab Anmeldemethode den Anmeldeanbieter Google.

      2. Kopiere die Webserver-Client-ID und den Clientschlüssel vom Anmeldeanbieter Google.

    3. Aktiviere auf dem Tab Anmeldemethode den Anmeldeanbieter Play Games und gib die Webserver-Client-ID und den Clientschlüssel deines Projekts an, die du im letzten Schritt erhalten hast.

Play Games services mit den Informationen deiner Firebase-App konfigurieren

  1. Öffne in der Google Play Console, deine Google Play App oder erstelle eine.

  2. Klicke im Bereich Wachstum auf Play Games services > Einrichtung und Verwaltung > Konfiguration.

  3. Klicke auf Ja, in meinem Spiel kommen bereits Google-APIs zum Einsatz, wähle dein Firebase Projekt aus der Liste aus und klicke dann auf Verwenden.

  4. Klicke auf der Play Games services Konfigurationsseite auf Anmeldedaten hinzufügen.

    1. Wähle den Typ Gameserver aus.
    2. Wähle im Feld OAuth-Client die Web-Client-ID deines Projekts aus. Achte darauf, dass es sich um dieselbe Client-ID handelt, die du beim Aktivieren der Play Games Anmeldung angegeben hast.
    3. Speichern Sie die Änderungen.

  5. Klicke noch einmal auf der Play Games services Konfigurationsseite auf Anmeldedaten hinzufügen.

    1. Wähle den Typ Android aus.
    2. Wähle im Feld OAuth-Client die Android-Client-ID deines Projekts aus. Wenn du deine Android-Client-ID nicht siehst, achte darauf, dass du den SHA-1-Fingerabdruck deines Spiels in der Firebase Console festgelegt hast.
    3. Speichern Sie die Änderungen.

  6. Füge auf der Seite Tester die E-Mail-Adressen aller Nutzer hinzu, die sich in deinem Spiel anmelden können müssen, bevor du es im Play Store veröffentlichst.

Play Games-Anmeldung in dein Spiel einbinden

Bevor sich Spieler in deinem Spiel anmelden können, musst du die Google Play Games-Anmeldung einbinden.

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

So fügst du deinem Spiel die Play Games-Anmeldung mit dem Google Sign-in C++ SDK hinzu:

  1. Klone oder lade das Google Sign-in Unity-Plug-in-Repository, das auch das C++ SDK enthält.

  2. Erstelle das Projekt im Verzeichnis staging/native/ entweder mit Android Studio oder gradlew build.

    Bei der Erstellung wird die Ausgabe in ein Verzeichnis mit dem Namen google-signin-cpp kopiert.

  3. Füge das Google Sign-in C++ SDK in die Make-Datei des nativen Codes deines Spiels ein:

    CMake

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

  4. Füge als Nächstes die Java-Hilfskomponente hinzu, die für das C++ SDK erforderlich ist.

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

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

    Deklariere die Hilfskomponente in der build.gradle-Datei auf Modulebene als Abhängigkeit:

    dependencies {
    implementation 'com.google.android.gms:play-services-auth:22.0.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. Konfiguriere dann in deinem Spiel ein GoogleSignIn-Objekt, um die Play Games-Anmeldung zu verwenden und einen Serverautorisierungscode abzurufen:

    #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. Rufe schließlich SignIn() auf, um den Spieler bei Play Games anzumelden:

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

    Wenn die von SignIn() zurückgegebene Future aufgelöst wird, kannst du den Serverautorisierungscode 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 Games angemeldet hat, kannst du den Autorisierungscode verwenden, um dich bei Firebase zu authentifizieren.

  1. Nachdem sich der Spieler erfolgreich mit Play Games angemeldet hat, rufe einen Autorisierungscode für das Konto des Spielers ab.

  2. Tausche dann den Autorisierungscode von den Play Games-Diensten gegen Anmeldedaten für Firebase ein und authentifiziere den Spieler mit den Firebase-Anmeldedaten:

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

  3. Wenn dein Programm eine Aktualisierungsschleife hat, die regelmäßig ausgeführt wird (z. B. 30- oder 60-mal pro Sekunde), kannst du die Ergebnisse einmal pro Aktualisierung 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 dein Programm ereignisgesteuert ist, kannst du auch einen Callback für die Future registrieren.

Callback für eine Future registrieren

Einige Programme haben Update-Funktionen, die 30- oder 60-mal pro Sekunde aufgerufen werden. Viele Spiele folgen diesem Modell. Diese Programme können die LastResult-Funktionen aufrufen, um asynchrone Aufrufe abzufragen. Wenn dein Programm ereignisgesteuert ist, kannst du auch Callback-Funktionen registrieren. Eine Callback-Funktion wird nach Abschluss der Future 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 Callback-Funktion kann auch ein Lambda 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

Wenn sich ein Nutzer zum ersten Mal anmeldet, wird ein neues Nutzerkonto erstellt und mit seiner Play Games-ID verknüpft. Dieses neue Konto wird als Teil deines Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in allen Apps deines Projekts zu identifizieren.

In deinem Spiel kannst du die Firebase-UID des Nutzers aus dem 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 den Sicherheitsregeln für die Firebase Realtime Database und Cloud Storage kannst du die eindeutige Nutzer-ID des angemeldeten Nutzers aus der Variablen auth abrufen und damit steuern, auf welche Daten ein Nutzer zugreifen kann.

Wenn du die Spielerinformationen eines Nutzers für Play Games abrufen oder auf die Play Games-Dienste zugreifen möchtest, verwende die APIs, die vom Google Play Games-Dienste C++ SDK bereitgestellt werden.

Rufe SignOut() auf, um einen Nutzer abzumelden:

auth->SignOut();