S'authentifier avec Google sur Android

Vous pouvez autoriser vos utilisateurs à s'authentifier avec Firebase à l'aide de leurs comptes Google.

Avant de commencer

1. Si ce n'est pas encore fait, ajoutez Firebase à votre projet Android.

2. Dans le fichier Gradle de votre module (au niveau de l'application) (généralement <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), ajoutez la dépendance pour la bibliothèque Firebase Authentication pour Android. Nous vous recommandons d'utiliser Firebase Android BoM pour contrôler le contrôle des versions de la bibliothèque.

   De plus, lors de la configuration de Firebase Authentication, vous devez ajouter le SDK du Gestionnaire d'identifiants à votre application.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.16.0"))
   
       // Add the dependency for the Firebase Authentication library
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-auth")
   
       // Also add the dependencies for the Credential Manager libraries and specify their versions
       implementation("androidx.credentials:credentials:1.3.0")
       implementation("androidx.credentials:credentials-play-services-auth:1.3.0")
       implementation("com.google.android.libraries.identity.googleid:googleid:1.1.1")
   }

   En utilisant Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.

   (Alternative) Ajoutez des dépendances de bibliothèque Firebase sans utiliser BoM.

   Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier chaque version de la bibliothèque Firebase dans sa ligne de dépendance.

   Notez que si vous utilisez plusieurs bibliothèques Firebase dans votre application, nous vous recommandons vivement d'utiliser BoM pour gérer les versions de la bibliothèque, ce qui garantit que toutes les versions sont compatibles.

   dependencies {
       // Add the dependency for the Firebase Authentication library
       // When NOT using the BoM, you must specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-auth:23.2.1")
   
       // Also add the dependencies for the Credential Manager libraries and specify their versions
       implementation("androidx.credentials:credentials:1.3.0")
       implementation("androidx.credentials:credentials-play-services-auth:1.3.0")
       implementation("com.google.android.libraries.identity.googleid:googleid:1.1.1")
   }

   Vous recherchez un module de bibliothèque spécifique à Kotlin ? À partir d'octobre 2023 (Firebase BoM 32.5.0), les développeurs Kotlin et Java peuvent dépendre du module de bibliothèque principal (pour en savoir plus, consultez les questions fréquentes sur cette initiative).

3. Si vous n'avez pas encore spécifié l'empreinte SHA de votre application, faites-le sur la page des paramètres de la console Firebase. Pour savoir comment obtenir l'empreinte SHA de votre application, consultez la section Authentifier votre client.

4. Activez Google comme méthode de connexion dans la console Firebase :
   1. Dans la console Firebase, ouvrez la section Auth.
   2. Dans l'onglet Mode de connexion, activez la méthode de connexion Google, puis cliquez sur Enregistrer.

5. Lorsque vous y êtes invité dans la console, téléchargez le fichier de configuration Firebase mis à jour (google-services.json), qui contient désormais les informations client OAuth requises pour Google Sign-In.

6. Déplacez ce fichier de configuration mis à jour dans votre projet Android Studio, en remplaçant le fichier de configuration correspondant désormais obsolète. (voir Ajouter Firebase à votre projet Android).

Authentifier avec Firebase

1. Intégrez Se connecter avec Google à votre application en suivant la procédure décrite dans la documentation du Gestionnaire d'identifiants. Voici les instructions générales :
   1. Instancier une requête de connexion Google à l'aide de GetGoogleIdOption. Créez ensuite la requête du Gestionnaire d'identifiants à l'aide de GetCredentialRequest:

      Kotlin

      // Instantiate a Google sign-in request
      val googleIdOption = GetGoogleIdOption.Builder()
          // Your server's client ID, not your Android client ID.
          .setServerClientId(getString(R.string.default_web_client_id))
          // Only show accounts previously used to sign in.
          .setFilterByAuthorizedAccounts(true)
          .build()
      
      // Create the Credential Manager request
      val request = GetCredentialRequest.Builder()
          .addCredentialOption(googleIdOption)
          .build()
      GoogleSignInActivity.kt

      Java

      // Instantiate a Google sign-in request
      GetGoogleIdOption googleIdOption = new GetGoogleIdOption.Builder()
              .setFilterByAuthorizedAccounts(true)
              .setServerClientId(getString(R.string.default_web_client_id))
              .build();
      
      // Create the Credential Manager request
      GetCredentialRequest request = new GetCredentialRequest.Builder()
              .addCredentialOption(googleIdOption)
              .build();
      GoogleSignInActivity.java

      Dans la requête ci-dessus, vous devez transmettre votre ID client "serveur" à la méthode setServerClientId. Pour trouver l'ID client OAuth 2.0:

      1. Ouvrez la page Identifiants dans la console Google Cloud.
      2. L'ID client de type application Web est l'ID client OAuth 2.0 de votre serveur backend.
   2. Après avoir intégré Se connecter avec Google, vérifiez que votre activité de connexion contient un code semblable à celui-ci:

      Kotlin

      private fun handleSignIn(credential: Credential) {
          // Check if credential is of type Google ID
          if (credential is CustomCredential && credential.type == TYPE_GOOGLE_ID_TOKEN_CREDENTIAL) {
              // Create Google ID Token
              val googleIdTokenCredential = GoogleIdTokenCredential.createFrom(credential.data)
      
              // Sign in to Firebase with using the token
              firebaseAuthWithGoogle(googleIdTokenCredential.idToken)
          } else {
              Log.w(TAG, "Credential is not of type Google ID!")
          }
      }
      GoogleSignInActivity.kt

      Java

      private void handleSignIn(Credential credential) {
          // Check if credential is of type Google ID
          if (credential instanceof CustomCredential customCredential
                  && credential.getType().equals(TYPE_GOOGLE_ID_TOKEN_CREDENTIAL)) {
              // Create Google ID Token
              Bundle credentialData = customCredential.getData();
              GoogleIdTokenCredential googleIdTokenCredential = GoogleIdTokenCredential.createFrom(credentialData);
      
              // Sign in to Firebase with using the token
              firebaseAuthWithGoogle(googleIdTokenCredential.getIdToken());
          } else {
              Log.w(TAG, "Credential is not of type Google ID!");
          }
      }
      GoogleSignInActivity.java

2. Dans la méthode onCreate de votre activité de connexion, obtenez l'instance partagée de l'objet FirebaseAuth:

   Kotlin

   private lateinit var auth: FirebaseAuth
   // ...
   // Initialize Firebase Auth
   auth = Firebase.auth
   GoogleSignInActivity.kt

   Java

   private FirebaseAuth mAuth;
   // ...
   // Initialize Firebase Auth
   mAuth = FirebaseAuth.getInstance();
   GoogleSignInActivity.java

3. Lorsque vous initialisez votre activité, vérifiez si l'utilisateur est actuellement connecté:

   Kotlin

   override fun onStart() {
       super.onStart()
       // Check if user is signed in (non-null) and update UI accordingly.
       val currentUser = auth.currentUser
       updateUI(currentUser)
   }
   GoogleSignInActivity.kt

   Java

   @Override
   public void onStart() {
       super.onStart();
       // Check if user is signed in (non-null) and update UI accordingly.
       FirebaseUser currentUser = mAuth.getCurrentUser();
       updateUI(currentUser);
   }
   GoogleSignInActivity.java

4. Obtenez maintenant le jeton d'identification Google créé à l'étape 1, échangez-le contre des identifiants Firebase, puis authentifiez-vous avec Firebase à l'aide des identifiants Firebase:

   Kotlin

   private fun firebaseAuthWithGoogle(idToken: String) {
       val credential = GoogleAuthProvider.getCredential(idToken, null)
       auth.signInWithCredential(credential)
           .addOnCompleteListener(this) { task ->
               if (task.isSuccessful) {
                   // Sign in success, update UI with the signed-in user's information
                   Log.d(TAG, "signInWithCredential:success")
                   val user = auth.currentUser
                   updateUI(user)
               } else {
                   // If sign in fails, display a message to the user
                   Log.w(TAG, "signInWithCredential:failure", task.exception)
                   updateUI(null)
               }
           }
   }
   GoogleSignInActivity.kt

   Java

   private void firebaseAuthWithGoogle(String idToken) {
       AuthCredential credential = GoogleAuthProvider.getCredential(idToken, null);
       mAuth.signInWithCredential(credential)
               .addOnCompleteListener(this, task -> {
                   if (task.isSuccessful()) {
                       // Sign in success, update UI with the signed-in user's information
                       Log.d(TAG, "signInWithCredential:success");
                       FirebaseUser user = mAuth.getCurrentUser();
                       updateUI(user);
                   } else {
                       // If sign in fails, display a message to the user
                       Log.w(TAG, "signInWithCredential:failure", task.getException());
                       updateUI(null);
                   }
               });
   }
   GoogleSignInActivity.java

   Si l'appel à signInWithCredential aboutit, vous pouvez utiliser la méthode getCurrentUser pour obtenir les données de compte de l'utilisateur.

Étapes suivantes

Lorsqu'un utilisateur se connecte pour la première fois, un compte utilisateur est créé et associé aux identifiants (nom et mot de passe de l'utilisateur, numéro de téléphone ou informations du fournisseur d'authentification) avec lesquels l'utilisateur s'est connecté. Ce nouveau compte est stocké dans votre projet Firebase et peut être utilisé pour identifier un utilisateur dans toutes les applications de votre projet, quelle que soit la manière dont il se connecte.

• Dans vos applications, vous pouvez obtenir les informations de profil de base de l'utilisateur à partir de l'objet FirebaseUser. Consultez Gérer les utilisateurs.

• Dans vos règles de sécurité Firebase Realtime Database et Cloud Storage, vous pouvez obtenir l'ID utilisateur unique de l'utilisateur connecté à partir de la variable auth et l'utiliser pour contrôler les données auxquelles un utilisateur peut accéder.

Vous pouvez autoriser les utilisateurs à se connecter à votre application à l'aide de plusieurs fournisseurs d'authentification en associant les identifiants du fournisseur d'authentification à un compte utilisateur existant.

Pour déconnecter un utilisateur, appelez signOut. Vous devez également effacer l'état des identifiants utilisateur actuels de tous les fournisseurs d'identifiants, comme recommandé dans la documentation du Gestionnaire d'identifiants:

private fun signOut() {
    // Firebase sign out
    auth.signOut()

    // When a user signs out, clear the current user credential state from all credential providers.
    lifecycleScope.launch {
        try {
            val clearRequest = ClearCredentialStateRequest()
            credentialManager.clearCredentialState(clearRequest)
            updateUI(null)
        } catch (e: ClearCredentialException) {
            Log.e(TAG, "Couldn't clear user credentials: ${e.localizedMessage}")
        }
    }
}
GoogleSignInActivity.kt

private void signOut() {
    // Firebase sign out
    mAuth.signOut();

    // When a user signs out, clear the current user credential state from all credential providers.
    ClearCredentialStateRequest clearRequest = new ClearCredentialStateRequest();
    credentialManager.clearCredentialStateAsync(
            clearRequest,
            new CancellationSignal(),
            Executors.newSingleThreadExecutor(),
            new CredentialManagerCallback<>() {
                @Override
                public void onResult(@NonNull Void result) {
                    updateUI(null);
                }

                @Override
                public void onError(@NonNull ClearCredentialException e) {
                    Log.e(TAG, "Couldn't clear user credentials: " + e.getLocalizedMessage());
                }
            });
}
GoogleSignInActivity.java