Wdrażanie funkcji Zaloguj się przez Google

Z tego przewodnika dowiesz się, jak wdrożyć Zaloguj się przez Google. Opisujemy w nim te kroki:

Dodaj zależności do aplikacji.
Utwórz instancję CredentialManager.
Utwórz proces planszy dolnej.
Utwórz przepływ przycisku.
Obsłuż odpowiedź logowania.
Obsługuj błędy.
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.6.0-rc02")
    implementation("androidx.credentials:credentials-play-services-auth:1.6.0-rc02")
    implementation("com.google.android.libraries.identity.googleid:googleid:<latest version>")
}

Groovy

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

Utwórz instancję Menedżera danych logowania

Użyj aplikacji lub kontekstu aktywności, aby utworzyć obiekt CredentialManager.

// 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 Menedżera danych logowania. Korzystanie z tego interfejsu zapewnia spójność we wszystkich metodach uwierzytelniania, takich jak hasła, klucze dostępu i Zaloguj się przez Google.

Konfigurowanie prośby o zalogowanie na wcześniej autoryzowanych kontach

Spróbuj wysłać prośbę o zalogowanie się w Google za pomocą GetGoogleIdOption, aby pobrać token identyfikacyjny 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:

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

Pamiętaj, że domyślna wartość parametru setFilterByAuthorizedAccounts to true, co oznacza, że domyślnym działaniem interfejsu arkusza dolnego jest wyświetlanie tylko wcześniej autoryzowanych kont.
Ustaw identyfikator klienta serwera: ustaw parametr setServerClientId. webClientId to identyfikator klienta usługi internetowej skonfigurowany na potrzeby OAuth w projekcie Google Cloud podczas spełniania 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). W przypadku użytkowników aplikacji eliminuje to niepotrzebne utrudnienia, 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 jedno autoryzowane konto, które było wcześniej używane do logowania się w aplikacji na tym urządzeniu. Wiele autoryzowanych kont na urządzeniu wyłącza automatyczne logowanie.
- 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 uwzględnić wartość nonce na potrzeby weryfikacji po stronie serwera za pomocą setNonce(). Sprawdź, czy kod po stronie serwera weryfikuje, czy wartości nonce w żądaniu i odpowiedzi są identyczne.

Aby wygenerować wartość nonce, użyj funkcji podobnej do tej, która generuje silną kryptograficznie losową wartość nonce o określonej długości i koduje ją za pomocą funkcji 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 autoryzowane konto na urządzeniu, 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 prośby o logowanie, jeśli nie są dostępne żadne autoryzowane konta

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

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

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

Tworzenie przepływu przycisku

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

Użytkownik zamknął planszę dolną interfejsu Menedżera danych logowania.
Na urządzeniu nie ma kont Google.
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 prośbę o zalogowanie się w Google za pomocą parametru GetSignInWithGoogleOption, aby pobrać identyfikator tokena Google.

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

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

Utwórz funkcję logowania udostępnionego dla planszy dolnej i przycisku.

Aby obsłużyć logowanie, wykonaj te czynności:

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

Uwaga: jeśli konwersja zakończy się niepowodzeniem z błędem GoogleIdTokenParsingException, może być konieczne zaktualizowanie biblioteki Zaloguj się przez Google.
Sprawdź dane logowania na serwerze jednostki uzależnionej.
Sprawdź, czy prawidłowo obsługujesz błędy.

Uwaga: zanim użyjesz otrzymanego tokena identyfikatora do zalogowania użytkownika w aplikacji, musisz potwierdzić 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 tożsamości 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

Sprawdź błędy wymienione w sekcji Rozwiązywanie problemów, aby upewnić się, że 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 przypadku przyszłych żądań logowania. Może na przykład nadać priorytet aktywnym danym logowania przed innymi dostępnymi danymi logowania.

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