Uwierzytelnianie w usługach gier Google Play na Androidzie

Za pomocą usług Gier Google Play możesz logować graczy w grach na Androida utworzonych w Firebase. Aby korzystać z logowania się w usługach Gier Google Play przez Firebase, najpierw zaloguj gracza w Grach 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 uwierzytelniania w Firebase.

Zanim zaczniesz

Skonfiguruj projekt na Androida

  1. Dodaj Firebase do swojego projektu na Androida, jeśli jeszcze go nie masz.

  2. W pliku Gradle na poziomie modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle) dodaj zależność do biblioteki uwierzytelniania Firebase na Androida. Do kontrolowania obsługi wersji biblioteki zalecamy używanie BOM Firebase na Androida.

    Podczas konfigurowania Uwierzytelniania Firebase musisz też dodać do aplikacji pakiet SDK Usług Google Play.

    dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.1.0"))

    // Add the dependency for the Firebase Authentication library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth")
    
    // Also add the dependency for the Google Play services library and specify its version
    implementation("com.google.android.gms:play-services-auth:21.2.0")    
}

    Dzięki wykorzystaniu BM od Firebase Android Twoja aplikacja zawsze będzie używała zgodnych wersji bibliotek Firebase na Androida.

    (Alternatywnie) Dodaj zależności biblioteki Firebase bez użycia BoM.

    Jeśli nie chcesz używać BoM Firebase, musisz określić każdą wersję biblioteki Firebase w wierszu zależności.

    Pamiętaj, że jeśli w aplikacji używasz wielu bibliotek Firebase, zdecydowanie zalecamy korzystanie z BoM do zarządzania wersjami biblioteki. Zapewni to zgodność wszystkich wersji. 

    dependencies {
    // Add the dependency for the Firebase Authentication library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-auth:23.0.0")
    
    // Also add the dependency for the Google Play services library and specify its version
    implementation("com.google.android.gms:play-services-auth:21.2.0")    
}
    Szukasz modułu biblioteki dotyczącego konkretnego narzędzia Kotlin? Od października 2023 r. (Firebase BoM w wersji 32.5.0) deweloperzy korzystający z Kotlin i Javy mogą korzystać z modułu biblioteki głównej (szczegółowe informacje znajdziesz w odpowiedziach na najczęstsze pytania na temat tej inicjatywy).

Skonfiguruj projekt Firebase

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

    Skrót SHA Twojego certyfikatu podpisywania możesz uzyskać za pomocą polecenia gradle signingReport:

    ./gradlew signingReport

  2. Włącz Gry Google Play jako dostawcę logowania:

    1. Znajdź identyfikator klienta serwera WWW i tajny klucz klienta. Identyfikator klienta serwera WWW identyfikuje Twój projekt Firebase na serwerach uwierzytelniania Google Play.

      Aby znaleźć te wartości:

      1. Otwórz projekt Firebase na stronie danych logowania w konsoli interfejsów API Google.
      2. W sekcji Identyfikatory klienta OAuth 2.0 otwórz stronę szczegółów Klienta internetowego (utworzonego automatycznie przez usługę Google). Znajdziesz na niej identyfikator klienta i tajny klucz serwera.

    2. Następnie w konsoli Firebase otwórz sekcję Uwierzytelnianie.

    3. Na karcie Metoda logowania włącz dostawcę logowania w Grach Play. Musisz podać identyfikator klienta serwera WWW swojego projektu i tajny klucz klienta uzyskane z konsoli interfejsów API.

Konfigurowanie usług Gier Play przy użyciu informacji o aplikacji Firebase

  1. W Konsoli Google Play otwórz aplikację Google Play lub ją utwórz.

  2. W sekcji Rozwój kliknij Usługi gier Play > Konfiguracja i zarządzanie > Konfiguracja.

  3. Kliknij Tak, moja gra już korzysta z interfejsów API Google, wybierz swój projekt Firebase z listy i kliknij Użyj.

  4. Na stronie konfiguracji usług gier Play kliknij Dodaj dane logowania.

    1. Wybierz typ Serwer gier.
    2. W polu Klient OAuth wybierz identyfikator klienta internetowego projektu. Musi to być ten sam identyfikator klienta, który został podany przy logowaniu się w Grach Play.
    3. Zapisz zmiany.

  5. Pozostając na stronie konfiguracji usług gier Play, ponownie kliknij Dodaj dane logowania.

    1. Wybierz typ Android.
    2. W polu Klient OAuth wybierz identyfikator klienta Androida w projekcie. (Jeśli nie widzisz swojego identyfikatora klienta Androida, sprawdź, czy w konsoli Firebase masz ustawiony odcisk cyfrowy SHA-1 swojej gry).
    3. Zapisz zmiany.

  6. Na stronie Testerzy dodaj adresy e-mail wszystkich użytkowników, którzy mają mieć możliwość logowania się w Twojej grze, zanim opublikujesz ją w Sklepie Play.

Zintegruj logowanie się w Grach Play ze swoją grą

Najpierw zintegruj w swojej aplikacji logowanie się w Grach Play. Instrukcje znajdziesz w artykule Logowanie się w Grach na Androida.

Gdy w integracji tworzysz obiekt GoogleSignInOptions, użyj konfiguracji DEFAULT_GAMES_SIGN_IN i wywołaj requestServerAuthCode:

Kotlin+KTX

val gso = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
    .requestServerAuthCode(getString(R.string.default_web_client_id))
    .build()
MainActivity.kt

Java

GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestServerAuthCode(getString(R.string.default_web_client_id))
        .build();
MainActivity.java

Do metody requestServerAuthCode musisz przekazać identyfikator klienta serwera WWW. Jest to identyfikator podany przez Ciebie podczas włączania logowania w Grach Play w konsoli Firebase.

Uwierzytelnij za pomocą Firebase

Po dodaniu w aplikacji funkcji logowania się przez Gry Play musisz skonfigurować Firebase tak, aby używała danych logowania do konta Google, które otrzymujesz, gdy gracz loguje się w Grach Play.

  1. Najpierw w metodzie onCreate aktywności logowania pobierz udostępnione wystąpienie obiektu FirebaseAuth:

Kotlin+KTX

private lateinit var auth: FirebaseAuth
// ...
// Initialize Firebase Auth
auth = Firebase.auth
GoogleSignInActivity.kt

Java

private FirebaseAuth mAuth;
// ...
// Initialize Firebase Auth
mAuth = FirebaseAuth.getInstance();
GoogleSignInActivity.java
  1. Inicjując aktywność, sprawdź, czy użytkownik jest już zalogowany w Firebase:

Kotlin+KTX

override fun onStart() {
    super.onStart()
    // Check if user is signed in (non-null) and update UI accordingly.
    val currentUser = auth.currentUser
    updateUI(currentUser)
}
GoogleSignInActivity.kt

Java

@Override
public void onStart() {
    super.onStart();
    // Check if user is signed in (non-null) and update UI accordingly.
    FirebaseUser currentUser = mAuth.getCurrentUser();
    updateUI(currentUser);
}
GoogleSignInActivity.java
If the player isn't signed in, present the player with your game's
signed-out experience, including the option to sign in.
  1. Gdy gracz zaloguje się w Grach Play dyskretnie lub interaktywnie, pobierz kod autoryzacji z obiektu GoogleSignInAccount, wymień go na dane logowania w Firebase i uwierzytelnij się w tej usłudze za pomocą danych logowania Firebase:

Kotlin+KTX

// Call this both in the silent sign-in task's OnCompleteListener and in the
// Activity's onActivityResult handler.
private fun firebaseAuthWithPlayGames(acct: GoogleSignInAccount) {
    Log.d(TAG, "firebaseAuthWithPlayGames:" + acct.id!!)

    val auth = Firebase.auth
    val credential = PlayGamesAuthProvider.getCredential(acct.serverAuthCode!!)
    auth.signInWithCredential(credential)
        .addOnCompleteListener(this) { task ->
            if (task.isSuccessful) {
                // Sign in success, update UI with the signed-in user's information
                Log.d(TAG, "signInWithCredential:success")
                val user = auth.currentUser
                updateUI(user)
            } else {
                // If sign in fails, display a message to the user.
                Log.w(TAG, "signInWithCredential:failure", task.exception)
                Toast.makeText(
                    baseContext,
                    "Authentication failed.",
                    Toast.LENGTH_SHORT,
                ).show()
                updateUI(null)
            }

            // ...
        }
}
MainActivity.kt

Java

// Call this both in the silent sign-in task's OnCompleteListener and in the
// Activity's onActivityResult handler.
private void firebaseAuthWithPlayGames(GoogleSignInAccount acct) {
    Log.d(TAG, "firebaseAuthWithPlayGames:" + acct.getId());

    final FirebaseAuth auth = FirebaseAuth.getInstance();
    AuthCredential credential = PlayGamesAuthProvider.getCredential(acct.getServerAuthCode());
    auth.signInWithCredential(credential)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (task.isSuccessful()) {
                        // Sign in success, update UI with the signed-in user's information
                        Log.d(TAG, "signInWithCredential:success");
                        FirebaseUser user = auth.getCurrentUser();
                        updateUI(user);
                    } else {
                        // If sign in fails, display a message to the user.
                        Log.w(TAG, "signInWithCredential:failure", task.getException());
                        Toast.makeText(MainActivity.this, "Authentication failed.",
                                Toast.LENGTH_SHORT).show();
                        updateUI(null);
                    }

                    // ...
                }
            });
}
MainActivity.java

Jeśli wywołanie funkcji signInWithCredential się powiedzie, możesz pobrać dane konta użytkownika za pomocą metody getCurrentUser.

Dalsze kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika, które zostanie powiązane z jego identyfikatorem w Grach Play. Nowe konto jest przechowywane w ramach projektu Firebase i może służyć do identyfikowania użytkowników w każdej aplikacji w projekcie.

Identyfikator UID użytkownika w grze możesz uzyskać z obiektu FirebaseUser:

Kotlin+KTX

val user = auth.currentUser
user?.let {
    val playerName = it.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 FirebaseUser.getIdToken() instead.
    val uid = it.uid
}

MainActivity.kt

Java

FirebaseUser user = mAuth.getCurrentUser();
String playerName = user.getDisplayName();

// 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 FirebaseUser.getIdToken() instead.
String uid = user.getUid();
MainActivity.java

W regułach zabezpieczeń Bazy danych czasu rzeczywistego i Cloud Storage w Bazie danych czasu rzeczywistego Firebase możesz pobrać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i za jego pomocą kontrolować, do jakich danych ma on dostęp.

Aby uzyskać informacje o odtwarzaczu Gier Play użytkownika lub uzyskać dostęp do usług Gier Play, użyj interfejsów API udostępnianych przez pakiet SDK Gier Google Play.

Aby wylogować użytkownika, zadzwoń pod numer FirebaseAuth.signOut():

Kotlin+KTX

Firebase.auth.signOut()
MainActivity.kt

Java

FirebaseAuth.getInstance().signOut();
MainActivity.java