Wdrażanie funkcji Zaloguj się przez Google

Z tego przewodnika dowiesz się, jak zaimplementować funkcję Zaloguj się przez Google. Omówimy w nim te kroki:

Dodawanie zależności do aplikacji.
Tworzenie instancji CredentialManager.
Tworzenie przepływu planszy dolnej.
Tworzenie przepływu przycisku.
Obsługa odpowiedzi na logowanie.
Obsługa błędów.
Obsługa wylogowania.

Dodawanie zależności do aplikacji

W pliku build.gradle modułu zadeklaruj zależności, używając najnowszej wersji Credential Managera, uwierzytelniania w Usługach Google Play i googleid:

Kotlin

dependencies {
    implementation("androidx.credentials:credentials:1.7.0-alpha01")
    implementation("androidx.credentials:credentials-play-services-auth:1.7.0-alpha01")
    implementation("com.google.android.libraries.identity.googleid:googleid:<latest version>")
}

Groovy

dependencies {
    implementation "androidx.credentials:credentials:1.7.0-alpha01"
    implementation "androidx.credentials:credentials-play-services-auth:1.7.0-alpha01"
    implementation "com.google.android.libraries.identity.googleid:googleid:<latest version>"
}

Tworzenie instancji Credential Managera

Aby utworzyć obiekt CredentialManager, użyj kontekstu aplikacji lub aktywności.

// Use your app or activity context to instantiate a client instance of
// CredentialManager.
private val credentialManager = CredentialManager.create(context)

Tworzenie przepływu planszy dolnej

Plansza dolna to wbudowany interfejs Credential Managera. Dzięki niemu możesz zapewnić spójne działanie wszystkich metod uwierzytelniania, takich jak hasła, klucze dostępu i funkcja Zaloguj się przez Google.

Konfigurowanie żądania logowania na wcześniej autoryzowanych kontach

Spróbuj wysłać żądanie logowania przez Google za pomocą GetGoogleIdOption aby pobrać token identyfikatora Google użytkownika.

Poniższe fragmenty kodu sprawdzają, czy konto jest autoryzowane.

val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
    .setFilterByAuthorizedAccounts(true)
    .setServerClientId(WEB_CLIENT_ID)
    .setAutoSelectEnabled(true)
    .setNonce(generateSecureRandomNonce())
    .build()

Obiekt żądania googleIdOption jest skonfigurowany w ten sposób:

Filtruj wcześniej autoryzowane konta: aby pobrać autoryzowane konta, które były wcześniej używane do logowania się w Twojej aplikacji, ustaw setFilterByAuthorizedAccounts na true.

Pamiętaj, że domyślna wartość setFilterByAuthorizedAccounts to true, co oznacza, że domyślnie interfejs planszy dolnej wyświetla tylko wcześniej autoryzowane konta.
Ustaw identyfikator klienta serwera: ustaw parametr setServerClientId. webClientId to identyfikator klienta usługi internetowej, który został skonfigurowany na potrzeby OAuth w projekcie Google Cloud podczas wykonywania wymagań wstępnych.
Włącz logowanie automatyczne (opcjonalnie): aby włączyć logowanie automatyczne dla powracających użytkowników, użyj setAutoSelectEnabled(true) i setFilterByAuthorizedAccounts(true). Dzięki temu użytkownicy aplikacji nie będą musieli wykonywać niepotrzebnych czynności, jeśli byli już wcześniej zalogowani.

Logowanie automatyczne jest możliwe tylko wtedy, gdy spełnione są te kryteria:
- Na urządzeniu jest tylko 1 autoryzowane konto, które było wcześniej używane do logowania się w aplikacji na tym urządzeniu. Jeśli na urządzeniu jest kilka autoryzowanych kont, automatyczne logowanie jest wyłączone.
- Użytkownik nie wylogował się z aplikacji podczas poprzedniej sesji.
- Użytkownik nie wyłączył logowania automatycznego w ustawieniach konta Google.
Ustaw nonce (opcjonalnie): aby zwiększyć bezpieczeństwo, ustaw nonce na potrzeby weryfikacji po stronie serwera. Aby zapobiec atakom typu replay, możesz dołączyć nonce na potrzeby weryfikacji po stronie serwera za pomocą setNonce(). Sprawdź, czy kod po stronie serwera weryfikuje, czy nonce żądania i odpowiedzi są identyczne.

Aby wygenerować nonce, użyj funkcji podobnej do tej, która generuje silny kryptograficznie losowy nonce o określonej długości i koduje go za pomocą Base64:

fun generateSecureRandomNonce(byteLength: Int = 32): String {
    val randomBytes = ByteArray(byteLength)
    SecureRandom().nextBytes(randomBytes)
    return Base64.encodeToString(randomBytes, Base64.NO_WRAP or Base64.URL_SAFE or Base64.NO_PADDING)
}

Sprawdź, czy użytkownik ma na urządzeniu autoryzowane konto, wywołując metodę getCredential:

val request: GetCredentialRequest = GetCredentialRequest.Builder()
    .addCredentialOption(googleIdOption)
    .build()

coroutineScope {
    try {
        val result = credentialManager.getCredential(
            request = request,
            context = activityContext,
        )
        handleSignIn(result)
    } catch (e: GetCredentialException) {
        // Handle failures
    }
}

Konfigurowanie żądania logowania, jeśli nie ma dostępnych autoryzowanych kont

Jeśli na urządzeniu nie ma autoryzowanych użytkowników Twojej aplikacji, CredentialManager zwraca NoCredentialException. W takim przypadku wyłącz filtr autoryzowanych kont, aby użytkownik mógł zarejestrować się za pomocą innego konta.

val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
    .setFilterByAuthorizedAccounts(false)
    .setServerClientId(WEB_CLIENT_ID)
    .setNonce(generateSecureRandomNonce())
    .build()

Następnie poproś o zalogowanie się w taki sam sposób jak w przypadku autoryzowanych kont.

Tworzenie przepływu przycisku

Użyj przycisku, jeśli chcesz, aby użytkownicy mogli zalogować się przez Google w tych przypadkach:

Użytkownik zamknął interfejs planszy dolnej Credential Managera.
Na urządzeniu nie ma kont Google.
Istniejące konta na urządzeniu wymagają ponownego uwierzytelnienia.

Tworzenie interfejsu przycisku

Możesz to zrobić za pomocą przycisku Jetpack Compose, ale możesz też użyć wstępnie zatwierdzonej ikony marki ze strony Wytyczne dotyczące marki Zaloguj się przez Google.

Utwórz żądanie logowania przez Google za pomocą GetSignInWithGoogleOption, aby pobrać token identyfikatora Google.

val signInWithGoogleOption: GetSignInWithGoogleOption = GetSignInWithGoogleOption.Builder(
    serverClientId = WEB_CLIENT_ID
).setNonce(generateSecureRandomNonce())
    .build()

Następnie poproś o zalogowanie się w taki sam sposób jak w przypadku interfejsu planszy dolnej.

Tworzenie wspólnej funkcji logowania na potrzeby planszy dolnej i przycisku

Aby obsługiwać logowanie, wykonaj te czynności:

Użyj funkcji getCredential() Credential Managera. Jeśli odpowiedź jest prawidłowa, wyodrębnij CustomCredential, który powinien być typu GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL.
Przekonwertuj obiekt na GoogleIdTokenCredential za pomocą metody GoogleIdTokenCredential.createFrom().

Uwaga: jeśli konwersja nie powiedzie się z powodu GoogleIdTokenParsingException, to może być konieczne zaktualizowanie wersji biblioteki Zaloguj się przez Google.
Sprawdź dane logowania na serwerze jednostki uzależnionej.
Upewnij się, że prawidłowo obsługujesz błędy.

Uwaga: zanim zaufasz tokenowi identyfikatora, który otrzymasz, aby zalogować użytkownika w aplikacji, musisz sprawdzić jego autentyczność. Aby zweryfikować token, wyślij googleIdTokenCredential.getIdToken() na swój serwer. Więcej informacji o weryfikacji po stronie serwera znajdziesz w artykule Weryfikowanie tokena identyfikatora Google po stronie serwera.

fun handleSign(result: GetCredentialResponse) {
    // Handle the successfully returned credential.
    val credential = result.credential

    when (credential) {
        is CustomCredential -> {
            if (credential.type == GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL) {
                try {
                    // Use googleIdTokenCredential and extract the ID for server-side validation.
                    val googleIdTokenCredential = GoogleIdTokenCredential
                        .createFrom(credential.data)
                } catch (e: GoogleIdTokenParsingException) {
                    Log.e(TAG, "Received an invalid google id token response", e)
                }
            } else {
                // Catch any unrecognized credential type here.
                Log.e(TAG, "Unexpected type of credential")
            }
        }

        else -> {
            // Catch any unrecognized credential type here.
            Log.e(TAG, "Unexpected type of credential")
        }
    }
}

Obsługa błędów

Zapoznaj się z błędami wymienionymi w sekcji Rozwiązywanie problemów, aby mieć pewność, że Twój kod obsługuje wszystkie możliwe scenariusze błędów.

Obsługa wylogowania

Ważne jest, aby zapewnić użytkownikom możliwość wylogowania się z aplikacji. Użytkownik może na przykład mieć na urządzeniu kilka kont Google i zdecydować się na zalogowanie z innego konta. Możesz to zrobić np. na stronie ustawień.

Dostawca danych logowania może przechowywać aktywną sesję danych logowania i używać jej do ograniczania opcji logowania w przyszłych żądaniach logowania. Może na przykład traktować aktywne dane logowania jako priorytetowe w stosunku do innych dostępnych danych logowania.

Gdy użytkownik wyloguje się z Twojej aplikacji, wywołaj metodę interfejsu API clearCredentialState() , aby usunąć stan bieżących danych logowania użytkownika ze wszystkich dostawców danych logowania. Spowoduje to powiadomienie wszystkich dostawców danych logowania, że należy usunąć wszystkie przechowywane sesje danych logowania dla danej aplikacji, co zapewni użytkownikom pełne opcje logowania przy następnym logowaniu.