Check out what’s new from Firebase at Google I/O 2022. Learn more

Ajoutez facilement une connexion à votre application Android avec FirebaseUI

FirebaseUI est une bibliothèque construite au-dessus du SDK d'authentification Firebase qui fournit des flux d'interface utilisateur à utiliser dans votre application. FirebaseUI offre les avantages suivants :

  • Fournisseurs multiples - flux de connexion pour e-mail/mot de passe, lien e-mail, authentification par téléphone, connexion Google, connexion Facebook, connexion Twitter et connexion GitHub.
  • Gestion de compte - flux pour gérer les tâches de gestion de compte, telles que la création de compte et les réinitialisations de mot de passe.
  • Liaison de compte - 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, comme FirebaseUI est open source, vous pouvez bifurquer 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 sur plusieurs 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 prenez en charge Google Sign-in et que vous n'avez pas encore spécifié l'empreinte SHA-1 de votre application, faites-le à partir de 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-1 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>
    

S'identifier

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

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);
            }
        }
);

Kotlin+KTX

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

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

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);

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)

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

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

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

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 d' 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 e-mail.

  2. Dans la même section, activez la méthode de connexion par lien par 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 de messagerie. Dans la console Firebase , cliquez sur Dynamic Links sous Engage 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 e-mail envoyés à vos utilisateurs.

  4. Vous pouvez activer la connexion par lien de messagerie 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 à la 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.

    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);

    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)
  5. Si vous souhaitez attraper le lien dans une activité spécifique, veuillez suivre les étapes décrites ici . Sinon, le lien redirigera vers votre activité de lanceur.

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

    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);
        }
    }

    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)
        }
    }
  7. La connexion facultative par lien de messagerie multi-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 de plusieurs 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 Firebase Authentication ainsi que de tous les fournisseurs d'identité sociale :

Java

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

Kotlin+KTX

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

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

Java

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

Kotlin+KTX

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

Personnalisation

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

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);

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)

Vous pouvez également définir une politique de confidentialité et des conditions d'utilisation personnalisées :

Java

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

Kotlin+KTX

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

Prochaines étapes

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