Authentifizierung über die Google Play-Spieldienste mit C++

Sie können die Google Play Games-Dienste verwenden, um Spieler bei einem Android-Spiel anzumelden, das auf Firebase basiert und in C++ geschrieben ist. Um die Anmeldung bei den Google Play Games-Diensten mit Firebase zu verwenden, melden Sie sich zuerst beim Player mit Google Play Games an und fordern Sie dabei einen OAuth 2.0-Authentifizierungscode an. Dann übergeben Sie den Auth - Code zu PlayGamesAuthProvider eine Firebase Berechtigungsnachweis zu generieren, die Sie mit Firebase authentifizieren können.

Bevor Sie beginnen

Bevor Sie können Firebase - Authentifizierung , müssen Sie:

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

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

  • Fügen Sie die Firebase C ++ SDK zu Ihrem C ++ Projekt.

Beachten Sie, dass das Hinzufügen Firebase zu Ihrem C ++ Projekt umfasst Aufgaben sowohl in der Firebase - Konsole und in der offenen C ++ Projekt (zB Sie Firebase Konfigurationsdateien von der Konsole herunterladen, dann bewegen Sie sie in Ihr C ++ Projekt).

Richten Sie Ihr Firebase-Projekt ein

  1. Wenn Sie nicht bereits haben, setzen Sie Ihr Spiel des SHA-1 Fingerabdruck in der Settings - Seite der Konsole Firebase.

    Sie können den SHA - Hash Ihres Signaturzertifikats mit dem gradle erhalten signingReport Befehl:

    ./gradlew signingReport

  2. Aktivieren Sie Google Play Games als Anmeldeanbieter:

    1. Suchen Sie die Webserver-Client-ID und das Client-Geheimnis Ihres Projekts. Die Webserver-Client-ID identifiziert Ihr Firebase-Projekt gegenüber den Google Play-Authentifizierungsservern.

      So finden Sie diese Werte:

      1. Öffnen Sie Ihr Firebase - Projekt in der Google APIs - Konsole Anmeldeinformationen Seite.
      2. In dem OAuth 2.0 - Client - IDs Abschnitt, öffnen Sie den Web - Client (automatisch erstellt von Google Service) Detailseite. Auf dieser Seite werden Ihre Webserver-Client-ID und Ihr Geheimnis aufgeführt.
    2. Dann wird in der Firebase Konsole , öffnen den Abschnitt Authentication.

    3. Auf dem Anmelden Methode Registerkarte, aktivieren Sie die Play Games-Anmeldung Anbieter. Sie müssen die Webserver-Client-ID und das Client-Geheimnis Ihres Projekts angeben, die Sie von der APIs-Konsole erhalten haben.

  1. In der Google Play - Konsole , öffnen Sie Ihre App oder erstellen.

  2. In GROW Abschnitt, klicken Sie auf Spiele Play - Dienste> Setup & Management> Konfiguration.

  3. Klicken Sie auf Ja, mein Spiel bereits benutzt Google APIs, wählen Sie den Namen Ihrer Firebase Projekt aus der Liste, und klicken Sie auf Verwenden.

  4. Auf der Play Games Services - Konfiguration Seite, klicken Sie auf Hinzufügen Credential.

    1. Wählen Sie das Spiel Servertyp.
    2. Im OAuth Client - Feld, wählen Sie Ihr Projekt ID Web - Client. Stellen Sie sicher, dass dies dieselbe Client-ID ist, die Sie bei der Aktivierung der Play Spiele-Anmeldung angegeben haben.
    3. Speichern Sie Ihre Änderungen.
  5. Noch immer auf der Play Games Services - Konfiguration Seite, klicken Sie auf Hinzufügen erneut Credential.

    1. Wählen Sie die Android - Typ.
    2. Im OAuth Client - Feld, wählen Sie Ihr Projekt Android - Client - ID. (Wenn Ihre Android-Client-ID nicht angezeigt wird, stellen Sie sicher, dass Sie den SHA-1-Fingerabdruck Ihres Spiels in der Firebase-Konsole festlegen.)
    3. Speichern Sie Ihre Änderungen.
  6. Auf der Tester Seite, fügen Sie die E - Mail - Adressen der Benutzer, die sich in Ihrem Spiel zu unterschreiben können , bevor Sie es in der Play Store veröffentlichen.

Integrieren Sie die Play Games-Anmeldung in Ihr Spiel

Bevor Sie Spieler bei Ihrem Spiel anmelden können, müssen Sie die Anmeldung bei Google Play Games integrieren.

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

Gehen Sie wie folgt vor, um die Play Games-Anmeldung mit dem Google Sign-in C++ SDK zu Ihrem Spiel hinzuzufügen:

  1. Clone oder laden Sie die Google - Sign-in Unity - Plugin - Repository , das auch die C ++ SDK enthält.

  2. Erstellen Sie das Projekt in dem enthaltenen staging/native/ Verzeichnis, entweder mit Android Studio oder gradlew build .

    Die Build kopiert seine Ausgabe zu einem Verzeichnis mit dem Namen google-signin-cpp .

  3. Fügen Sie das Google Sign-in C++ SDK in die native Code-Make-Datei Ihres Spiels ein:

    CMake

    In der obersten Ebene Ihrer CMakeLists.txt - Datei:

    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 Ihrer Android.mk - Datei:

    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ügen Sie als Nächstes die Java-Hilfskomponente hinzu, die für das C++-SDK erforderlich ist.

    Um dies zu tun, in Ihrer Projektebene build.gradle Datei, fügen Sie das SDK Build - Ausgabeverzeichnis als lokales Repository:

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

    Und in der Modulebene build.gradle Datei, erklären die Helfer Komponente als Abhängigkeit:

    dependencies {
        implementation 'com.google.android.gms:play-services-auth:19.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')
    }
    
  5. Dann in Ihrem Spiel, configure ein GoogleSignIn Objekt Verwendung Play Games Anmelde- und einen Server Auth - Code 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. Schließlich ruft SignIn() in den Player zu unterzeichnen Spiele zu spielen:

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

    Wenn die Zukunft von zurück SignIn() löst, können Sie den Server Auth - Code aus dem Ergebnis:

    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 bei Play Games angemeldet hat, können Sie sich mit dem Authentifizierungscode bei Firebase authentifizieren.

  1. Nachdem sich der Spieler erfolgreich mit Play Games angemeldet hat, erhalten Sie einen Authentifizierungscode für das Konto des Spielers.

  2. Tauschen Sie dann den Authentifizierungscode der Play Spiele-Dienste gegen Firebase-Anmeldeinformationen aus und verwenden Sie die Firebase-Anmeldeinformationen, um den Spieler zu authentifizieren:

    firebase::auth::Credential credential =
        firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  3. Wenn Ihr Programm eine Update - Schleife hat , dass läuft regelmäßig (etwa bei 30 oder 60 mal pro Sekunde), können Sie die Ergebnisse überprüfen einmal pro Update mit Auth::SignInWithCredentialLastResult :

    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredentialLastResult();
    if (result.status() == firebase::kFutureStatusComplete) {
      if (result.error() == firebase::auth::kAuthErrorNone) {
        firebase::auth::User* user = *result.result();
        printf("Sign in succeeded for `%s`\n", user->display_name().c_str());
      } else {
        printf("Sign in failed with error '%s'\n", result.error_message());
      }
    }

    Oder, wenn Ihr Programm ereignisgesteuert, können Sie es vorziehen , um einen Rückruf über die Zukunft zu registrieren .

Registrieren Sie einen Rückruf auf einem Future

Einige Programme haben Update , die 30 oder 60 Mal pro Sekunde aufgerufen werden. Viele Spiele folgen beispielsweise diesem Modell. Diese Programme können den Anruf LastResult Funktionen asynchrone Aufrufe abzufragen. Wenn Ihr Programm jedoch ereignisgesteuert ist, können Sie es vorziehen, Callback-Funktionen zu registrieren. Eine Callback-Funktion wird nach Abschluss des 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::User*> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}
Die Callback - Funktion kann auch eine Lambda sein, wenn Sie es vorziehen.
void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::User*> 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 Benutzer zum ersten Mal anmeldet, wird ein neues Benutzerkonto erstellt und mit seiner Play Games-ID verknüpft. Dieses neue Konto wird als Teil Ihres Firebase-Projekts gespeichert und kann verwendet werden, um einen Nutzer in jeder App in Ihrem Projekt zu identifizieren.

In Ihrem Spiel, können Sie die Benutzerfirebase UID aus dem erhaltenen firebase::auth::User

firebase::auth::User* user = auth->current_user();
if (user != nullptr) {
  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 Ihrer Datenbank und Firebase Realtime Cloud Storage Sicherheitsregeln, können Sie die angemeldeten Nutzer die eindeutige Benutzer - ID aus der bekommen auth Variable, und es verwenden , um steuern kann ein Benutzer Zugriff , welche Daten.

Um einen Play Games Spielerinformationen des Benutzers oder dem Zugriff auf Play Games - Dienste nutzen , die von den bereitgestellten APIs Google Play Games - Diensten C ++ SDK .

Um einen Benutzer abzumelden, rufen SignOut() :

auth->SignOut();