Ajoutez facilement une connexion à votre application Android avec FirebaseUI

FirebaseUI est une bibliothèque basée sur le SDK Firebase Authentication. Elle fournit des flux d'UI prêts à l'emploi pour votre application. FirebaseUI offre les avantages suivants :

• Fournisseurs multiples : flux de connexion pour l'authentification par e-mail/mot de passe, lien par e-mail, authentification par téléphone, connexion avec Google, connexion avec Facebook, connexion avec Twitter et connexion avec GitHub.
• Gestion de compte : flux permettant de gérer les tâches de gestion de compte, comme la création de compte et la réinitialisation du mot de passe.
• Association de compte : flux permettant d'associer de manière sécurisée les comptes utilisateur à différents fournisseurs d'identité.
• Mise à niveau des utilisateurs anonymes : flux permettant de mettre à niveau les utilisateurs anonymes de manière sécurisée.
• Thèmes personnalisés : personnalisez l'apparence de FirebaseUI pour qu'elle corresponde à votre application. De plus, comme FirebaseUI est open source, vous pouvez forker le projet et le personnaliser exactement selon vos besoins.
• Credential Manager : intégration automatique à Credential Manager pour une connexion rapide sur plusieurs appareils.

Avant de commencer

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

2. Ajoutez les dépendances pour FirebaseUI à votre fichier build.gradle(.kts) au niveau de l'application. Si vous souhaitez prendre en charge la connexion avec Facebook ou Twitter, incluez également les SDK Facebook et Twitter :

       dependencies {
           // ...
   
           implementation("com.firebaseui:firebase-ui-auth:9.0.0")
   
           // Required only if Facebook login support is required
           // Find the latest Facebook SDK releases here: https://goo.gl/Ce5L94
           implementation("com.facebook.android:facebook-android-sdk:8.x")
       }
   

   Le SDK FirebaseUI Auth a des dépendances transitives sur le SDK Firebase et le SDK des services Google Play.

3. Dans la console Firebase, accédez à Sécurité > Authentification.

4. Dans l'onglet Mode de connexion, activez les fournisseurs de connexion que vous souhaitez prendre en charge. Certains fournisseurs d'identité nécessitent des informations supplémentaires, généralement disponibles dans la console pour les développeurs du service.

5. Si vous avez activé Se connecter avec Google :

   1. Mettez à jour votre fichier de configuration Firebase.

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

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

   2. Spécifiez l'empreinte SHA-1 de votre application si ce n'est pas déjà fait.

      1. Dans la consoleFirebase, accédez à l'onglet Général > settings Paramètres.

      2. Faites défiler la page jusqu'à la fiche Vos applications, sélectionnez votre application Android, puis ajoutez votre empreinte SHA-1 dans le champ Empreintes de certificat SHA.

      Pour savoir comment obtenir l'empreinte SHA de votre application, consultez Authentifier votre client.

6. Si vous acceptez la connexion avec Facebook ou Twitter, ajoutez des ressources de chaîne à strings.xml qui spécifient les informations d'identification requises par chaque fournisseur :

   
   <resources>
     <!-- Facebook application ID and custom URL scheme (app ID prefixed by 'fb'). -->
     <string name="facebook_application_id" translatable="false">YOUR_APP_ID</string>
     <string name="facebook_login_protocol_scheme" translatable="false">fbYOUR_APP_ID</string>
   </resources>

Se connecter

Créez un ActivityResultLauncher qui enregistre un rappel pour le contrat de résultat d'activité FirebaseUI :

// See: https://developer.android.com/training/basics/intents/result
private val signInLauncher = registerForActivityResult(
    FirebaseAuthUIActivityResultContract(),
) { res ->
    this.onSignInResult(res)
}
FirebaseUIActivity.kt

// See: https://developer.android.com/training/basics/intents/result
private final ActivityResultLauncher<Intent> signInLauncher = registerForActivityResult(
        new FirebaseAuthUIActivityResultContract(),
        new ActivityResultCallback<FirebaseAuthUIAuthenticationResult>() {
            @Override
            public void onActivityResult(FirebaseAuthUIAuthenticationResult result) {
                onSignInResult(result);
            }
        }
);
FirebaseUIActivity.java

Pour lancer le flux de connexion FirebaseUI, créez un intent de connexion avec vos méthodes de connexion préférées :

// Choose authentication providers
val providers = arrayListOf(
    AuthUI.IdpConfig.EmailBuilder().build(),
    AuthUI.IdpConfig.PhoneBuilder().build(),
    AuthUI.IdpConfig.GoogleBuilder().build(),
    AuthUI.IdpConfig.FacebookBuilder().build(),
    AuthUI.IdpConfig.TwitterBuilder().build(),
)

// Create and launch sign-in intent
val signInIntent = AuthUI.getInstance()
    .createSignInIntentBuilder()
    .setAvailableProviders(providers)
    .build()
signInLauncher.launch(signInIntent)
FirebaseUIActivity.kt

// Choose authentication providers
List<AuthUI.IdpConfig> providers = Arrays.asList(
        new AuthUI.IdpConfig.EmailBuilder().build(),
        new AuthUI.IdpConfig.PhoneBuilder().build(),
        new AuthUI.IdpConfig.GoogleBuilder().build(),
        new AuthUI.IdpConfig.FacebookBuilder().build(),
        new AuthUI.IdpConfig.TwitterBuilder().build());

// Create and launch sign-in intent
Intent signInIntent = AuthUI.getInstance()
        .createSignInIntentBuilder()
        .setAvailableProviders(providers)
        .build();
signInLauncher.launch(signInIntent);
FirebaseUIActivity.java

Une fois le flux de connexion terminé, vous recevrez le résultat dans onSignInResult :

private fun onSignInResult(result: FirebaseAuthUIAuthenticationResult) {
    val response = result.idpResponse
    if (result.resultCode == RESULT_OK) {
        // Successfully signed in
        val user = FirebaseAuth.getInstance().currentUser
        // ...
    } else {
        // Sign in failed. If response is null the user canceled the
        // sign-in flow using the back button. Otherwise check
        // response.getError().getErrorCode() and handle the error.
        // ...
    }
}
FirebaseUIActivity.kt

private void onSignInResult(FirebaseAuthUIAuthenticationResult result) {
    IdpResponse response = result.getIdpResponse();
    if (result.getResultCode() == RESULT_OK) {
        // Successfully signed in
        FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();
        // ...
    } else {
        // Sign in failed. If response is null the user canceled the
        // sign-in flow using the back button. Otherwise check
        // response.getError().getErrorCode() and handle the error.
        // ...
    }
}
FirebaseUIActivity.java

Configurer des méthodes de connexion

Authentification par lien envoyé par e-mail

1. Dans la console Firebase, accédez à Sécurité > Authentification.

2. Dans l'onglet Mode de connexion, activez la méthode de connexion Adresse e-mail/Mot de passe. Notez que la connexion par e-mail/mot de passe doit être activée pour utiliser la connexion par lien d'e-mail.

3. Dans la même section, activez la méthode de connexion Lien envoyé par e-mail (connexion sans mot de passe), puis cliquez sur Enregistrer.

4. Vous devez également activer Firebase Dynamic Links pour utiliser la connexion par lien envoyé par e-mail :

   1. Dans la console Firebase, accédez à DevOps et engagement > Dynamic Links.

   2. Cliquez sur Commencer, puis ajoutez un domaine. Le domaine que vous choisissez ici sera reflété dans les liens des e-mails envoyés à vos utilisateurs.

5. Vous pouvez activer la connexion par lien e-mail dans FirebaseUI en appelant enableEmailLinkSignIn sur une instance EmailBuilder. Vous devrez également fournir un objet ActionCodeSettings valide avec setHandleCodeInApp défini sur "true".

   De plus, vous devez ajouter l'URL que vous transmettez à setUrl à la liste blanche :

   1. Dans la consoleFirebase, accédez à l'onglet Paramètres de Sécurité > Authentification.

   2. Dans la section Domaines autorisés, cliquez sur Ajouter un domaine, puis ajoutez votre domaine.

   Kotlin

   val actionCodeSettings = ActionCodeSettings.newBuilder()
       .setAndroidPackageName( // yourPackageName=
           "...", // installIfNotAvailable=
           true, // minimumVersion=
           null,
       )
       .setHandleCodeInApp(true) // This must be set to true
       .setUrl("https://google.com") // This URL needs to be whitelisted
       .build()
   
   val providers = listOf(
       EmailBuilder()
           .enableEmailLinkSignIn()
           .setActionCodeSettings(actionCodeSettings)
           .build(),
   )
   val signInIntent = AuthUI.getInstance()
       .createSignInIntentBuilder()
       .setAvailableProviders(providers)
       .build()
   signInLauncher.launch(signInIntent)
   FirebaseUIActivity.kt

   Java

   ActionCodeSettings actionCodeSettings = ActionCodeSettings.newBuilder()
           .setAndroidPackageName(
                   /* yourPackageName= */ "...",
                   /* installIfNotAvailable= */ true,
                   /* minimumVersion= */ null)
           .setHandleCodeInApp(true) // This must be set to true
           .setUrl("https://google.com") // This URL needs to be whitelisted
           .build();
   
   List<AuthUI.IdpConfig> providers = Arrays.asList(
           new AuthUI.IdpConfig.EmailBuilder()
                   .enableEmailLinkSignIn()
                   .setActionCodeSettings(actionCodeSettings)
                   .build()
   );
   Intent signInIntent = AuthUI.getInstance()
           .createSignInIntentBuilder()
           .setAvailableProviders(providers)
           .build();
   signInLauncher.launch(signInIntent);
   FirebaseUIActivity.java

6. Si vous souhaitez récupérer le lien dans une activité spécifique, veuillez suivre ces étapes. Sinon, le lien redirige vers l'activité du lanceur d'applications.

7. Une fois que vous avez récupéré le lien profond, vous devez appeler pour vérifier que nous pouvons le traiter pour vous. Si nous le pouvons, vous devez ensuite nous le transmettre via setEmailLink.

   Kotlin

   if (AuthUI.canHandleIntent(intent)) {
       val extras = intent.extras ?: return
       val link = extras.getString("email_link_sign_in")
       if (link != null) {
           val signInIntent = AuthUI.getInstance()
               .createSignInIntentBuilder()
               .setEmailLink(link)
               .setAvailableProviders(providers)
               .build()
           signInLauncher.launch(signInIntent)
       }
   }
   FirebaseUIActivity.kt

   Java

   if (AuthUI.canHandleIntent(getIntent())) {
       if (getIntent().getExtras() == null) {
           return;
       }
       String link = getIntent().getExtras().getString("email_link_sign_in");
       if (link != null) {
           Intent signInIntent = AuthUI.getInstance()
                   .createSignInIntentBuilder()
                   .setEmailLink(link)
                   .setAvailableProviders(providers)
                   .build();
           signInLauncher.launch(signInIntent);
       }
   }
   FirebaseUIActivity.java

8. Facultatif : la connexion par lien envoyé par e-mail sur plusieurs appareils est acceptée. Cela signifie que le lien envoyé par votre application Android peut être utilisé pour se connecter à vos applications Web ou Apple. Par défaut, la compatibilité multi-appareils est activée. Vous pouvez le désactiver en appelant setForceSameDevice sur l'instance EmailBuilder.

   Pour en savoir plus, consultez FirebaseUI-Web et FirebaseUI-iOS.

Se déconnecter

FirebaseUI fournit des méthodes pratiques pour se déconnecter de Firebase Authentication et de tous les fournisseurs d'identité sociale :

AuthUI.getInstance()
    .signOut(this)
    .addOnCompleteListener {
        // ...
    }
FirebaseUIActivity.kt

AuthUI.getInstance()
        .signOut(this)
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            public void onComplete(@NonNull Task<Void> task) {
                // ...
            }
        });
FirebaseUIActivity.java

Vous pouvez également supprimer complètement le compte de l'utilisateur :

AuthUI.getInstance()
    .delete(this)
    .addOnCompleteListener {
        // ...
    }
FirebaseUIActivity.kt

AuthUI.getInstance()
        .delete(this)
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                // ...
            }
        });
FirebaseUIActivity.java

Personnalisation

Par défaut, FirebaseUI utilise AppCompat pour la création de thèmes, ce qui signifie qu'il adoptera naturellement le jeu de couleurs de votre application. Si vous avez besoin d'une personnalisation plus poussée, vous pouvez transmettre un thème et un logo au générateur Intent de connexion :

val signInIntent = AuthUI.getInstance()
    .createSignInIntentBuilder()
    .setAvailableProviders(providers)
    .setLogo(R.drawable.my_great_logo) // Set logo drawable
    .setTheme(R.style.MySuperAppTheme) // Set theme
    .build()
signInLauncher.launch(signInIntent)
FirebaseUIActivity.kt

Intent signInIntent = AuthUI.getInstance()
        .createSignInIntentBuilder()
        .setAvailableProviders(providers)
        .setLogo(R.drawable.my_great_logo)      // Set logo drawable
        .setTheme(R.style.MySuperAppTheme)      // Set theme
        .build();
signInLauncher.launch(signInIntent);
FirebaseUIActivity.java

Vous pouvez également définir des règles de confidentialité et des conditions d'utilisation personnalisées :

val signInIntent = AuthUI.getInstance()
    .createSignInIntentBuilder()
    .setAvailableProviders(providers)
    .setTosAndPrivacyPolicyUrls(
        "https://example.com/terms.html",
        "https://example.com/privacy.html",
    )
    .build()
signInLauncher.launch(signInIntent)
FirebaseUIActivity.kt

Intent signInIntent = AuthUI.getInstance()
        .createSignInIntentBuilder()
        .setAvailableProviders(providers)
        .setTosAndPrivacyPolicyUrls(
                "https://example.com/terms.html",
                "https://example.com/privacy.html")
        .build();
signInLauncher.launch(signInIntent);
FirebaseUIActivity.java

Étapes suivantes

• Pour en savoir plus sur l'utilisation et la personnalisation de FirebaseUI, consultez le fichier README sur GitHub.
• Si vous rencontrez un problème dans FirebaseUI et que vous souhaitez le signaler, utilisez l'outil de suivi des problèmes GitHub.