Se connecter avec Google vous aide à intégrer rapidement l'authentification des utilisateurs à votre application Android. Les utilisateurs peuvent utiliser leur compte Google pour se connecter à votre application, donner leur consentement et partager de manière sécurisée leurs informations de profil avec votre application. La bibliothèque Jetpack du Gestionnaire d'identifiants d'Android facilite cette intégration, offrant une expérience cohérente sur tous les appareils Android à l'aide d'une seule API.
Ce document vous explique comment implémenter Se connecter avec Google dans les applications Android, configurer l'interface utilisateur du bouton Se connecter avec Google et configurer les expériences de connexion et d'inscription en un seul geste optimisées pour l'application. Pour une migration d'appareil fluide, Se connecter avec Google est compatible avec la connexion automatique. Sa nature multiplate-forme sur Android, iOS et les surfaces Web vous permet de fournir un accès à la connexion pour votre application sur n'importe quel appareil.
Pour configurer Se connecter avec Google, suivez ces deux étapes principales:
Configurez l'option Se connecter avec Google pour l'interface utilisateur de la bottom sheet du Gestionnaire d'identifiants. Vous pouvez configurer cette fonctionnalité pour inviter automatiquement l'utilisateur à se connecter. Si vous avez implémenté des clés d'accès ou des mots de passe, vous pouvez demander simultanément tous les types d'identifiants pertinents afin que l'utilisateur n'ait pas à se souvenir de l'option qu'il a utilisée précédemment pour se connecter.
Ajoutez le bouton Se connecter avec Google à l'interface utilisateur de votre application. Le bouton "Se connecter avec Google" permet aux utilisateurs d'utiliser facilement leurs comptes Google existants pour s'inscrire ou se connecter à des applications Android. Les utilisateurs cliquent sur le bouton "Se connecter avec Google" s'ils ignorent l'interface utilisateur de la bottom sheet ou s'ils souhaitent explicitement utiliser leur compte Google pour s'inscrire et se connecter. Pour les développeurs, cela signifie une intégration plus facile des utilisateurs et une réduction des frictions lors de l'inscription.
Ce document explique comment intégrer le bouton "Se connecter avec Google" et la boîte de dialogue bottom sheet à l'API Gestionnaire d'identifiants à l'aide de la bibliothèque d'aide de l'ID Google.
Configurer votre projet dans la console Google APIs
- Ouvrez votre projet dans la console API ou créez-en un si vous n'en avez pas déjà un.
- Sur la page de l'écran d'autorisation OAuth, assurez-vous que toutes les informations sont complètes et exactes.
- Assurez-vous que le nom, le logo et la page d'accueil de votre application sont corrects. Ces valeurs seront présentées aux utilisateurs sur l'écran de consentement Se connecter avec Google lors de l'inscription et sur l'écran Applis et services tiers.
- Assurez-vous d'avoir spécifié les URL des règles de confidentialité et des conditions d'utilisation de votre application.
- Sur la page "Identifiants", créez un ID client Android pour votre application si vous n'en avez pas déjà un. Vous devez spécifier le nom du package et la signature SHA-1 de votre application.
- Accédez à la page Identifiants.
- Cliquez sur Créer des identifiants > ID client OAuth.
- Sélectionnez le type d'application Android.
- Sur la page "Identifiants", créez un ID client "Application Web" si vous ne l'avez pas déjà fait. Pour le moment, vous pouvez ignorer les champs "Origines JavaScript autorisées" et "URI de redirection autorisés". Cet ID client servira à identifier votre serveur backend lorsqu'il communiquera avec les services d'authentification de Google.
- Accédez à la page Identifiants.
- Cliquez sur Créer des identifiants > ID client OAuth.
- Sélectionnez le type d'application Web.
Déclarer des dépendances
Dans le fichier build.gradle de votre module, déclarez les dépendances à l'aide de la dernière version du Gestionnaire d'identifiants:
dependencies {
// ... other dependencies
implementation "androidx.credentials:credentials:<latest version>"
implementation "androidx.credentials:credentials-play-services-auth:<latest version>"
implementation "com.google.android.libraries.identity.googleid:googleid:<latest version>"
}
Instancier une requête Google Sign-In
Pour commencer l'implémentation, instanciez une requête Google Sign-In. Utilisez GetGoogleIdOption pour récupérer le jeton d'ID Google d'un utilisateur.
val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
.setFilterByAuthorizedAccounts(true)
.setServerClientId(WEB_CLIENT_ID)
.setAutoSelectEnabled(true)
.setNonce(<nonce string to use when generating a Google ID token>)
.build()
Commencez par vérifier si l'utilisateur possède des comptes qui ont déjà été utilisés pour se connecter à votre application en appelant l'API avec le paramètre setFilterByAuthorizedAccounts défini sur true. Les utilisateurs peuvent choisir parmi les comptes disponibles pour se connecter.
Si aucun compte Google autorisé n'est disponible, l'utilisateur doit être invité à s'inscrire avec l'un de ses comptes disponibles. Pour ce faire, invitez l'utilisateur en appelant à nouveau l'API et en définissant setFilterByAuthorizedAccounts sur false.
En savoir plus sur l'inscription
Activer la connexion automatique pour les utilisateurs connus (recommandé)
Les développeurs doivent activer la connexion automatique pour les utilisateurs qui s'inscrivent avec leur compte unique. Cela offre une expérience fluide sur tous les appareils, en particulier pendant la migration, où les utilisateurs peuvent rapidement récupérer l'accès à leur compte sans avoir à saisir à nouveau leurs identifiants. Pour vos utilisateurs, cela élimine les frictions inutiles lorsqu'ils étaient déjà connectés.
Pour activer la connexion automatique, utilisez setAutoSelectEnabled(true). La connexion automatique n'est possible que si les conditions suivantes sont remplies:
- Un seul identifiant correspond à la requête, qui peut être un compte Google ou un mot de passe. Cet identifiant correspond au compte par défaut de l'appareil Android.
- L'utilisateur ne s'est pas explicitement déconnecté.
- L'utilisateur n'a pas désactivé la connexion automatique dans les paramètres de compte Google.
val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
.setFilterByAuthorizedAccounts(true)
.setServerClientId(WEB_CLIENT_ID)
.setAutoSelectEnabled(true)
.setNonce(<nonce string to use when generating a Google ID token>)
.build()
N'oubliez pas de gérer correctement la déconnexion lorsque vous implémentez la connexion automatique, afin que les utilisateurs puissent toujours choisir le bon compte après se déconnecter explicitement de votre application.
Définir un nonce pour améliorer la sécurité
Pour améliorer la sécurité de la connexion et éviter les attaques par rejeu, ajoutez setNonce pour inclure un nonce dans chaque requête. Découvrez comment générer un nonce.
val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
.setFilterByAuthorizedAccounts(true)
.setServerClientId(WEB_CLIENT_ID)
.setAutoSelectEnabled(true)
.setNonce(<nonce string to use when generating a Google ID token>)
.build()
Créer le flux Se connecter avec Google
Pour configurer un flux de connexion avec Google, procédez comme suit :
- Instanciez un
GetCredentialRequest, puis ajoutez l'googleIdOptioncréé précédemment à l'aide deaddCredentialOption()pour récupérer les identifiants. - Transmettez cette requête à l'appel
getCredential()(Kotlin) ougetCredentialAsync()(Java) pour récupérer les identifiants de l'utilisateur disponibles. - Une fois l'API établie, extrayez
CustomCredential, qui contient le résultat des donnéesGoogleIdTokenCredential. - Le type de
CustomCredentialdoit être égal à la valeur deGoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL. Convertissez l'objet enGoogleIdTokenCredentialà l'aide de la méthodeGoogleIdTokenCredential.createFrom. Si la conversion aboutit, extrayez l'ID
GoogleIdTokenCredential, validez-le et authentifiez les identifiants sur votre serveur.Si la conversion échoue avec une erreur
GoogleIdTokenParsingException, vous devrez peut-être mettre à jour la version de votre bibliothèque Se connecter avec Google.Récupérez tous les types d'identifiants personnalisés non reconnus.
val request: GetCredentialRequest = Builder()
.addCredentialOption(googleIdOption)
.build()
coroutineScope.launch {
try {
val result = credentialManager.getCredential(
request = request,
context = activityContext,
)
handleSignIn(result)
} catch (e: GetCredentialException) {
handleFailure(e)
}
}
fun handleSignIn(result: GetCredentialResponse) {
// Handle the successfully returned credential.
val credential = result.credential
when (credential) {
// Passkey credential
is PublicKeyCredential -> {
// Share responseJson such as a GetCredentialResponse on your server to
// validate and authenticate
responseJson = credential.authenticationResponseJson
}
// Password credential
is PasswordCredential -> {
// Send ID and password to your server to validate and authenticate.
val username = credential.id
val password = credential.password
}
// GoogleIdToken credential
is CustomCredential -> {
if (credential.type == GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL) {
try {
// Use googleIdTokenCredential and extract the ID to validate and
// authenticate on your server.
val googleIdTokenCredential = GoogleIdTokenCredential
.createFrom(credential.data)
// You can use the members of googleIdTokenCredential directly for UX
// purposes, but don't use them to store or control access to user
// data. For that you first need to validate the token:
// pass googleIdTokenCredential.getIdToken() to the backend server.
GoogleIdTokenVerifier verifier = ... // see validation instructions
GoogleIdToken idToken = verifier.verify(idTokenString);
// To get a stable account identifier (e.g. for storing user data),
// use the subject ID:
idToken.getPayload().getSubject()
} catch (e: GoogleIdTokenParsingException) {
Log.e(TAG, "Received an invalid google id token response", e)
}
} else {
// Catch any unrecognized custom credential type here.
Log.e(TAG, "Unexpected type of credential")
}
}
else -> {
// Catch any unrecognized credential type here.
Log.e(TAG, "Unexpected type of credential")
}
}
}
Déclencher un flux de bouton "Se connecter avec Google"
Pour déclencher le flux du bouton "Se connecter avec Google", utilisez GetSignInWithGoogleOption au lieu de GetGoogleIdOption:
val signInWithGoogleOption: GetSignInWithGoogleOption = GetSignInWithGoogleOption.Builder()
.setServerClientId(WEB_CLIENT_ID)
.setNonce(<nonce string to use when generating a Google ID token>)
.build()
Gérez le GoogleIdTokenCredential renvoyé comme décrit dans l'exemple de code suivant.
fun handleSignIn(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 id to validate and
// authenticate on your server.
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")
}
}
}
Une fois la requête de connexion Google créée, lancez le flux d'authentification comme indiqué dans la section Se connecter avec Google.
Activer l'inscription des nouveaux utilisateurs (recommandé)
Se connecter avec Google est le moyen le plus simple pour les utilisateurs de créer un compte en quelques gestes pour votre application ou votre service.
Si aucun identifiant enregistré n'est trouvé (aucun compte Google renvoyé par getGoogleIdOption), invitez l'utilisateur à s'inscrire. Tout d'abord, vérifiez si setFilterByAuthorizedAccounts(true) existe pour voir si des comptes précédemment utilisés existent. S'il n'en trouve aucun, invitez l'utilisateur à s'inscrire avec son compte Google en utilisant setFilterByAuthorizedAccounts(false).
Exemple :
val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
.setFilterByAuthorizedAccounts(false)
.setServerClientId(WEB_CLIENT_ID)
.build()
Une fois que vous avez instancié la demande d'inscription Google, lancez le flux d'authentification. Si les utilisateurs ne souhaitent pas utiliser Se connecter avec Google pour s'inscrire, envisagez d'optimiser votre application pour le remplissage automatique. Une fois que votre utilisateur a créé un compte, envisagez de l'inscrire aux clés d'accès comme dernière étape de la création de compte.
Gérer la déconnexion
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.
Cette opération informera tous les fournisseurs d'identifiants que toutes les sessions avec identifiants stockées pour l'application donnée doivent être effacées.
Un fournisseur d'identifiants peut avoir stocké une session d'identifiants active et l'utiliser pour limiter les options de connexion pour les futurs appels get-credential. Par exemple, il peut donner la priorité au jeu d'identification actif par rapport à tout autre identifiant disponible. Lorsque votre utilisateur se déconnecte explicitement de votre application et afin d'obtenir les options de connexion globales la prochaine fois, vous devez appeler cette API pour permettre au fournisseur d'effacer toute session avec identifiants stockée.