Ajoutez facilement une connexion à votre application Android avec FirebaseUI

FirebaseUI est une bibliothèque construite sur le SDK d'authentification Firebase qui fournit des flux d'interface utilisateur instantanés à utiliser dans votre application. FirebaseUI offre les avantages suivants :

  • Fournisseurs multiples : flux de connexion pour l'e-mail/mot de passe, le lien d'e-mail, l'authentification par téléphone, la connexion Google, la connexion Facebook, la connexion Twitter et la connexion GitHub.
  • Gestion de compte : flux permettant de gérer les tâches de gestion de compte, telles que la création de compte et la réinitialisation de mots de passe.
  • Liaison de comptes : flux permettant de lier en toute sécurité les comptes d'utilisateurs entre les fournisseurs d'identité.
  • Mise à niveau des utilisateurs anonymes : flux pour mettre à niveau en toute sécurité les utilisateurs anonymes.
  • Thèmes personnalisés : personnalisez l'apparence de FirebaseUI en fonction de votre application. De plus, étant donné que FirebaseUI est open source, vous pouvez créer le projet et le personnaliser exactement selon vos besoins.
  • Smart Lock for Passwords - intégration automatique avec Smart Lock for Passwords pour une connexion rapide entre appareils.

Avant que tu commences

  1. Si vous ne l'avez pas déjà fait, ajoutez Firebase à votre projet Android .

  2. Ajoutez les dépendances de FirebaseUI à votre fichier build.gradle 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:7.2.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 , ouvrez la section Authentification et activez les méthodes de connexion que vous souhaitez prendre en charge. Certaines méthodes de connexion nécessitent des informations supplémentaires, généralement disponibles dans la console développeur du service.

  4. Si vous avez activé Google Sign-in :

    1. 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 la connexion à Google.

    2. 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 .)

    3. 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. Voir Authentification de votre client pour plus de détails sur la façon d'obtenir l'empreinte SHA de votre application.

  5. Si vous prenez en charge 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 de l'activité FirebaseUI :

Kotlin+KTX

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

Java

// 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 une intention de connexion avec vos méthodes de connexion préférées :

Kotlin+KTX

// 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

Java

// 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 :

Kotlin+KTX

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

Java

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 les méthodes de connexion

  1. Dans la console Firebase , ouvrez la section Authentification . Dans l'onglet Méthode de connexion , activez le fournisseur 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 e-mail.

  2. Dans la même section, activez la méthode de connexion par lien e-mail (connexion sans mot de passe) et cliquez sur Enregistrer .

  3. Vous devrez également activer Firebase Dynamic Links pour utiliser la connexion par lien e-mail. Dans la console Firebase , cliquez sur Dynamic Links sous S'engager dans la barre de navigation. Cliquez sur Mise en route et ajoutez un domaine. Le domaine que vous choisissez ici sera reflété dans les liens de courrier électronique envoyés à vos utilisateurs.

  4. Vous pouvez activer la connexion par lien de courrier électronique dans FirebaseUI en appelant le enableEmailLinkSignIn sur une instance EmailBuilder . Vous devrez également fournir un objet ActionCodeSettings valide avec setHandleCodeInApp défini sur true. De plus, vous devez mettre sur liste blanche l'URL que vous transmettez à setUrl , ce qui peut être fait dans la console Firebase , sous Authentification -> Méthodes de connexion -> Domaines autorisés.

    Kotlin+KTX

    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

  5. Si vous souhaitez récupérer le lien dans une activité spécifique, veuillez suivre les étapes décrites ici . Sinon, le lien sera redirigé vers votre activité de lanceur.

  6. Une fois que vous aurez détecté le lien profond, vous devrez appeler pour vérifier que nous pouvons le gérer pour vous. Si nous le pouvons, vous devez ensuite nous le transmettre via setEmailLink .

    Kotlin+KTX

    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

  7. La connexion facultative par lien de courrier électronique entre appareils est prise en charge, ce qui signifie que le lien envoyé via votre application Android peut être utilisé pour vous connecter à vos applications Web ou Apple. Par défaut, la prise en charge multi-appareils est activée. Vous pouvez le désactiver en appelant setForceSameDevice sur l'instance EmailBuilder .

    Voir FirebaseUI-Web et FirebaseUI-iOS pour plus d'informations.

Se déconnecter

FirebaseUI fournit des méthodes pratiques pour se déconnecter de l'authentification Firebase ainsi que de tous les fournisseurs d'identité sociale :

Kotlin+KTX

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

Java

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 :

Kotlin+KTX

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

Java

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 la palette 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 connexion :

Kotlin+KTX

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

Java

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 une politique de confidentialité et des conditions d'utilisation personnalisées :

Kotlin+KTX

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

Java

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

Prochaines étapes

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