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

S'authentifier avec Google sur Android

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

Avant de commencer

Si ce n'est pas encore fait, ajoutez Firebase à votre projet Android.
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 de 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 des services Google Play à votre application.
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.5.1"))

    // 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 dependency for the Google Play services library and specify its version
    implementation("com.google.android.gms:play-services-auth:21.2.0")
}
```
En utilisant Firebase Android BoM, votre application utilisera toujours des versions compatibles des bibliothèques Firebase Android.
(Alternative) Ajoutez des dépendances de la bibliothèque Firebase sans utiliser la classe BoM.

Si vous choisissez de ne pas utiliser Firebase BoM, vous devez spécifier chaque version de 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.1.0")

    // Also add the dependency for the Google Play services library and specify its version
    implementation("com.google.android.gms:play-services-auth:21.2.0")
}
```
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).
Si vous n'avez pas encore spécifié l'empreinte SHA de votre application, faites-le depuis la page Paramètres de la console Firebase. Consultez la section Authentifier votre client pour savoir comment obtenir l'empreinte SHA de votre application.
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.
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 sur le client OAuth requises pour Google Sign-In.
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.)

S'authentifier avec Firebase

Intégrez la connexion Google One Tap à votre application en suivant la procédure décrite sur la page Se connecter avec les identifiants enregistrés. Lorsque vous configurez l'objet BeginSignInRequest, appelez setGoogleIdTokenRequestOptions :

Kotlin+KTX

signInRequest = BeginSignInRequest.builder()
            .setGoogleIdTokenRequestOptions(
                BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                    .setSupported(true)
                    // Your server's client ID, not your Android client ID.
                    .setServerClientId(getString(R.string.your_web_client_id))
                    // Only show accounts previously used to sign in.
                    .setFilterByAuthorizedAccounts(true)
                    .build())
            .build()

Java

signInRequest = BeginSignInRequest.builder()
    .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
            .setSupported(true)
            // 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())
    .build();

Vous devez transmettre votre ID client "serveur" à la méthode setGoogleIdTokenRequestOptions. Pour trouver l'ID client OAuth 2.0 :

Ouvrez la page Identifiants dans la console Google Cloud.
L'ID client de type application Web est l'ID client OAuth 2.0 de votre serveur backend.

Une fois que vous avez intégré la fonctionnalité de connexion Google, votre activité de connexion contient un code semblable au code suivant :

Kotlin+KTX

class YourActivity : AppCompatActivity() {

    // ...
    private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
    private var showOneTapUI = true
    // ...

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        when (requestCode) {
             REQ_ONE_TAP -> {
                try {
                    val credential = oneTapClient.getSignInCredentialFromIntent(data)
                    val idToken = credential.googleIdToken
                    when {
                        idToken != null -> {
                            // Got an ID token from Google. Use it to authenticate
                            // with Firebase.
                            Log.d(TAG, "Got ID token.")
                        }
                        else -> {
                            // Shouldn't happen.
                            Log.d(TAG, "No ID token!")
                        }
                    }
                } catch (e: ApiException) {
                    // ...
            }
        }
    }
    // ...
}

Java

public class YourActivity extends AppCompatActivity {

  // ...
  private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
  private boolean showOneTapUI = true;
  // ...

  @Override
  protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
      super.onActivityResult(requestCode, resultCode, data);

      switch (requestCode) {
          case REQ_ONE_TAP:
              try {
                  SignInCredential credential = oneTapClient.getSignInCredentialFromIntent(data);
                  String idToken = credential.getGoogleIdToken();
                  if (idToken !=  null) {
                      // Got an ID token from Google. Use it to authenticate
                      // with Firebase.
                      Log.d(TAG, "Got ID token.");
                  }
              } catch (ApiException e) {
                  // ...
              }
              break;
      }
  }
}

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

Kotlin+KTX

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

Java

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

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

Kotlin+KTX

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

Dans votre gestionnaire onActivityResult() (voir l'étape 1), obtenez le jeton d'ID Google de l'utilisateur, échangez-le contre des identifiants Firebase et authentifiez-vous auprès de Firebase à l'aide des identifiants Firebase:

Kotlin+KTX

val googleCredential = oneTapClient.getSignInCredentialFromIntent(data)
val idToken = googleCredential.googleIdToken
when {
    idToken != null -> {
        // Got an ID token from Google. Use it to authenticate
        // with Firebase.
        val firebaseCredential = GoogleAuthProvider.getCredential(idToken, null)
        auth.signInWithCredential(firebaseCredential)
                .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)
                    }
                }
    }
    else -> {
        // Shouldn't happen.
        Log.d(TAG, "No ID token!")
    }
}

Java

SignInCredential googleCredential = oneTapClient.getSignInCredentialFromIntent(data);
String idToken = googleCredential.getGoogleIdToken();
if (idToken !=  null) {
    // Got an ID token from Google. Use it to authenticate
    // with Firebase.
    AuthCredential firebaseCredential = GoogleAuthProvider.getCredential(idToken, null);
    mAuth.signInWithCredential(firebaseCredential)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> 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);
                    }
                }
            });
}

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 :

Kotlin+KTX

Firebase.auth.signOut()MainActivity.kt

Java

FirebaseAuth.getInstance().signOut();MainActivity.java