Implémenter Se connecter avec Google

Ce guide explique comment implémenter Se connecter avec Google et couvre les étapes suivantes :

Ajoutez des dépendances à votre application.
Instanciez CredentialManager.
Créez le flux du bottom sheet.
Créez le flux du bouton.
Gérez la réponse de connexion.
Gérez les erreurs.
Gérez la déconnexion.

Ajouter des dépendances à votre application

Dans le fichier build.gradle de votre module, déclarez les dépendances à l'aide de la dernière version de Credential Manager, Play Services Auth et 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>"
}

Instancier le Gestionnaire d'identifiants

Utilisez le contexte de votre application ou de votre activité pour créer un objet CredentialManager.

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

Créer le flux de la bottom sheet

Le bottom sheet est l'UI intégrée de Credential Manager. Cette UI permet de créer une expérience cohérente pour toutes les méthodes d'authentification, telles que les mots de passe, les clés d'accès et Se connecter avec Google.

Configurer la requête de connexion pour les comptes précédemment autorisés

Envoyez une requête de connexion Google avec GetGoogleIdOption pour récupérer le jeton d'ID Google de l'utilisateur.

Les extraits suivants vérifient si le compte est autorisé.

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

L'objet de requête googleIdOption est configuré comme suit :

Filtrer les comptes précédemment autorisés : pour récupérer les comptes autorisés qui ont déjà été utilisés pour se connecter à votre application, définissez setFilterByAuthorizedAccounts sur true.

Notez que la valeur par défaut de setFilterByAuthorizedAccounts est true, ce qui implique que le comportement par défaut de l'UI de la feuille inférieure est d'afficher uniquement les comptes précédemment autorisés.
Définissez l'ID client du serveur : définissez le paramètre setServerClientId. webClientId correspond à l'ID client Web que vous avez configuré pour OAuth dans votre projet Google Cloud lorsque vous avez rempli les conditions préalables.
Activer la connexion automatique (facultatif) : pour activer la connexion automatique pour les utilisateurs connus, utilisez setAutoSelectEnabled(true) et setFilterByAuthorizedAccounts(true). Pour les utilisateurs de votre application, cela élimine les frictions inutiles s'ils étaient déjà connectés.

La connexion automatique n'est possible que lorsque les conditions suivantes sont remplies :
- Un seul compte autorisé est enregistré sur l'appareil et il a déjà été utilisé pour se connecter à l'application sur l'appareil. Si plusieurs comptes autorisés sont présents sur l'appareil, la connexion automatique est désactivée.
- L'utilisateur ne s'est pas déconnecté explicitement de l'application lors de sa session précédente.
- L'utilisateur n'a pas désactivé la connexion automatique dans les paramètres de son compte Google.
Définissez un nonce (facultatif) : pour renforcer la sécurité, définissez un nonce pour la validation côté serveur. Pour éviter les attaques par relecture, vous pouvez inclure un nonce pour la validation côté serveur avec setNonce(). Assurez-vous que votre code côté serveur valide l'identité des nonces de requête et de réponse.

Pour générer le nonce, utilisez une fonction semblable à celle qui suit, qui génère un nonce aléatoire cryptographiquement sécurisé d'une longueur spécifiée et l'encode à l'aide de 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)
}

Vérifiez si l'utilisateur dispose d'un compte autorisé sur l'appareil en appelant la méthode 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
    }
}

Configurer la demande de connexion si aucun compte autorisé n'est disponible

S'il n'y a aucun utilisateur autorisé pour votre application sur l'appareil, CredentialManager renvoie un NoCredentialException. Dans ce cas, désactivez le filtre des comptes autorisés afin que l'utilisateur puisse s'inscrire avec un autre compte.

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

Ensuite, demandez la connexion de la même manière que pour les comptes autorisés.

Créer le flux du bouton

Utilisez un bouton si vous souhaitez que les utilisateurs puissent se connecter avec Google dans les conditions suivantes :

L'utilisateur a fermé l'UI de la bottom sheet Credential Manager.
Aucun compte Google n'est associé à l'appareil.
Les comptes existants sur l'appareil nécessitent une réauthentification.

Créer l'UI du bouton

Bien que cela puisse être fait avec un bouton Jetpack Compose, vous pouvez utiliser une icône de marque préapprouvée sur la page Consignes relatives à l'identité visuelle de Se connecter avec Google.

Créez une requête Google Sign-In avec GetSignInWithGoogleOption pour récupérer un jeton d'ID Google.

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

Ensuite, demandez la connexion de la même manière que pour l'UI de la feuille inférieure.

Créer la fonction de connexion partagée pour la bottom sheet et le bouton

Pour gérer la connexion, procédez comme suit :

Utilisez la fonction getCredential() de CredentialManager. Si la réponse est positive, extrayez le CustomCredential, qui doit être de type GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL.
Convertissez l'objet en GoogleIdTokenCredential à l'aide de la méthode GoogleIdTokenCredential.createFrom().

Remarque : Si la conversion échoue avec une erreur GoogleIdTokenParsingException, vous devrez peut-être mettre à jour la version de votre bibliothèque Se connecter avec Google.
Validez l'identifiant sur votre serveur de tiers de confiance.
Assurez-vous de gérer les erreurs de manière appropriée.

Remarque : Avant de faire confiance au jeton d'identité que vous recevez pour connecter l'utilisateur à votre application, vous devez valider l'authenticité de ce jeton. Pour valider le jeton, envoyez googleIdTokenCredential.getIdToken() à votre serveur. Pour en savoir plus sur la validation côté serveur, consultez Valider le jeton d'ID Google côté serveur.

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")
        }
    }
}

Gérer les erreurs

Consultez les erreurs listées dans Dépannage pour vous assurer que votre code gère tous les scénarios d'erreur possibles.

Gérer la déconnexion

Il est important de fournir à vos utilisateurs un mécanisme pour se déconnecter de votre application. Par exemple, un utilisateur peut avoir plusieurs comptes Google sur l'appareil et décider de se connecter à partir d'un autre compte. Vous pouvez le fournir, par exemple, sur la page des paramètres.

Un fournisseur d'identifiants peut stocker une session d'identifiants active et l'utiliser pour limiter les options de connexion pour les futures demandes de connexion. Par exemple, il peut donner la priorité à l'identifiant actif par rapport à tout autre identifiant disponible.

Lorsqu'un utilisateur se déconnecte de votre application, appelez la méthode clearCredentialState() de l'API pour effacer l'état actuel des identifiants utilisateur de tous les fournisseurs d'identifiants. Tous les fournisseurs d'identifiants seront ainsi informés que toute session d'identifiants stockée pour l'application concernée doit être effacée, ce qui permettra aux utilisateurs de disposer de toutes les options de connexion la prochaine fois.