Cette page a été traduite par l'API Cloud Translation.

Authentifier les utilisateurs avec Se connecter avec Google

Se connecter avec Google vous aide à intégrer rapidement l'authentification des utilisateurs à votre application Android. Les utilisateurs peuvent se connecter à votre application avec leur compte Google, donner leur consentement et partager de manière sécurisée les informations de leur profil avec votre application. La bibliothèque Jetpack Credential Manager d'Android facilite cette intégration, en offrant une expérience cohérente sur les appareils Android à l'aide d'une seule API.

Ce document vous explique comment implémenter Se connecter avec Google dans les applications Android, comment configurer l'UI du bouton Se connecter avec Google et comment configurer des expériences d'inscription et de connexion One Tap optimisées pour les applications. Pour une migration fluide des appareils, Se connecter avec Google prend en charge la connexion automatique. De plus, sa nature multiplate-forme sur Android, iOS et le Web vous aide à fournir un accès à la connexion pour votre application sur n'importe quel appareil. Si vous utilisez Firebase Authentication pour votre application, vous pouvez en savoir plus sur l'intégration de Se connecter avec Google et du Gestionnaire d'identifiants dans le guide Authentifier les utilisateurs dans Firebase avec Google sur Android.

Pour configurer Se connecter avec Google, suivez ces deux étapes principales :

Configurez Se connecter avec Google comme option pour l'UI de bottom sheet du Gestionnaire d'identifiants. Vous pouvez configurer cette option 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 tous les types d'identifiants pertinents simultanément, 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'UI de votre application. Le bouton "Se connecter avec Google" permet aux utilisateurs d'utiliser leurs comptes Google existants pour s'inscrire ou se connecter à des applications Android. Les utilisateurs cliqueront sur le bouton "Se connecter avec Google" s'ils ferment l'UI de la feuille inférieure ou s'ils souhaitent explicitement utiliser leur compte Google pour s'inscrire et se connecter. Pour les développeurs, cela signifie un onboarding des utilisateurs plus facile et moins de friction lors de l'inscription.

Animation montrant le flux Se connecter avec Google — **Figure 2.** UI du bouton "Se connecter avec Google" de Credential Manager

Ce document explique comment intégrer le bouton et la boîte de dialogue sous forme de bottom sheet "Se connecter avec Google" à l'API Credential Manager à l'aide de la bibliothèque d'aide Google ID.

Configurer votre projet

Ouvrez votre projet dans ou créez-en un si vous n'en avez pas encore.
Sur la page , assurez-vous que toutes les informations sont complètes et exactes.
1. 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 d'autorisation Se connecter avec Google lors de l'inscription et sur l'écran Applications et services tiers.
2. Assurez-vous d'avoir spécifié les URL des règles de confidentialité et des conditions d'utilisation de votre application.
Dans , créez un ID client Android pour votre application si vous n'en avez pas déjà un. Vous devrez spécifier le nom du package et la signature SHA-1 de votre application.
1. Accédez à .
2. Cliquez sur Créer un client.
3. Sélectionnez le type d'application Android.
Dans , créez un ID client "Application Web" si vous ne l'avez pas déjà fait. Vous pouvez ignorer les champs "Origines JavaScript autorisées" et "URI de redirection autorisés" pour le moment. Cet ID client servira à identifier votre serveur de backend lorsqu'il communiquera avec les services d'authentification de Google.
1. Accédez à .
2. Cliquez sur Créer un client.
3. Sélectionnez le type Application Web.

Déclarer des dépendances

Dans le fichier build.gradle de votre module, déclarez des 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)
  // nonce string to use when generating a Google ID token
  .setNonce(nonce)
.build()SignInWithGoogleFunctions.kt

Tout d'abord, vérifiez 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

Les développeurs doivent activer la connexion automatique pour les utilisateurs qui s'inscrivent avec leur compte unique. Cela permet d'offrir une expérience fluide sur tous les appareils, en particulier lors de la migration d'appareils, où les utilisateurs peuvent rapidement retrouver 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 lorsque les conditions suivantes sont remplies :

Il existe un seul identifiant correspondant à la requête, qui peut être un compte Google ou un mot de passe, et cet identifiant correspond au compte par défaut sur l'appareil fonctionnant sous Android.
L'utilisateur ne s'est pas déconnecté explicitement.
L'utilisateur n'a pas désactivé la connexion automatique dans les paramètres de son compte Google.

val googleIdOption: GetGoogleIdOption = GetGoogleIdOption.Builder()
  .setFilterByAuthorizedAccounts(true)
  .setServerClientId(WEB_CLIENT_ID)
  .setAutoSelectEnabled(true)
  // nonce string to use when generating a Google ID token
  .setNonce(nonce)
.build()SignInWithGoogleFunctions.kt

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 s'être déconnectés 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)
  // nonce string to use when generating a Google ID token
  .setNonce(nonce)
.build()SignInWithGoogleFunctions.kt

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 le googleIdOption créé précédemment à l'aide de addCredentialOption() pour récupérer les identifiants.
Transmettez cette requête à l'appel getCredential() (Kotlin) ou getCredentialAsync() (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ées GoogleIdTokenCredential.
Le type de CustomCredential doit être égal à la valeur de GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL. Convertissez l'objet en GoogleIdTokenCredential à l'aide de la méthode GoogleIdTokenCredential.createFrom.
Si la conversion aboutit, extrayez l'ID de 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 = GetCredentialRequest.Builder()
  .addCredentialOption(googleIdOption)
  .build()

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

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

  when (credential) {

    // Passkey credential
    is PublicKeyCredential -> {
      // Share responseJson such as a GetCredentialResponse to 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.
          // see [validation instructions](https://developers.google.com/identity/gsi/web/guides/verify-google-id-token)
        } 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")
    }
  }
}SignInWithGoogleFunctions.kt

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(
  serverClientId = WEB_CLIENT_ID
).setNonce(nonce)
  .build()SignInWithGoogleFunctions.kt

Gérez le GoogleIdTokenCredential renvoyé, comme décrit dans l'exemple de code suivant.

fun handleSignInWithGoogleOption(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")
    }
  }
}SignInWithGoogleFunctions.kt

Une fois la requête de connexion Google créée, lancez le flux d'authentification comme indiqué dans la section Se connecter avec Google.

Se connecter avec Google est le moyen le plus simple pour les utilisateurs de créer un compte avec votre application ou service en quelques gestes.

Si aucune identifiant enregistré n'est trouvé (aucun compte Google renvoyé par getGoogleIdOption), invitez l'utilisateur à s'inscrire. Commencez par vérifier si des comptes précédemment utilisés existent pour setFilterByAuthorizedAccounts(true). Si aucun n'est trouvé, 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()SignInWithGoogleFunctions.kt

Une fois la requête d'inscription Google créée, lancez le flux d'authentification. Si les utilisateurs ne souhaitent pas utiliser Se connecter avec Google pour s'inscrire, pensez à optimiser votre application pour la saisie automatique. Une fois que votre utilisateur a créé un compte, pensez à l'inscrire aux clés d'accès comme dernière étape de la création du 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. 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.

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é à l'identifiant 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 d'identifiants stockée.