Ajoutez facilement une connexion à votre application Android avec FirebaseUI

FirebaseUI Auth est une bibliothèque basée sur le SDK Firebase Authentication qui fournit des flux d'UI prêts à l'emploi pour votre application.

Le flux de connexion recommandé utilise des écrans Compose. Pour les applications qui utilisent encore des activités, consultez la section Applications existantes basées sur les activités.

FirebaseUI Auth offre les avantages suivants :

  • Plusieurs fournisseurs : flux de connexion pour l'adresse e-mail/le mot de passe, le téléphone, Google, Facebook, Apple, GitHub, Microsoft, Yahoo, Twitter, l'authentification anonyme et OAuth personnalisé.
  • 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 de 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 : prise en charge de l'UI Material 3 pouvant hériter du thème de 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.
  • Authentification multifacteur : compatible avec les SMS et le TOTP pour une sécurité renforcée.

Avant de commencer

  1. Si ce n'est pas déjà fait, ajoutez Firebase à votre projet Android.
  2. Dans la console Firebase, activez les méthodes de connexion que vous souhaitez prendre en charge.
  3. Ajoutez FirebaseUI Auth au module de votre application :
dependencies {
    // Check Maven Central for the latest version:
    // https://central.sonatype.com/artifact/com.firebaseui/firebase-ui-auth/versions
    implementation("com.firebaseui:firebase-ui-auth:10.0.0-beta02")

    // 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")
}

Configurer des méthodes de connexion

Google Sign-In

La configuration de Google Sign-In est automatiquement fournie par le fichier de configuration google-services.json. Assurez-vous d'avoir activé Google Sign-In dans la console Firebase.

Connexion avec Facebook

Si vous utilisez Facebook Login, ajoutez votre ID d'application Facebook à strings.xml :

<resources>
    <string name="facebook_application_id" translatable="false">YOUR_FACEBOOK_APP_ID</string>
    <string name="facebook_login_protocol_scheme" translatable="false">fbYOUR_FACEBOOK_APP_ID</string>
    <string name="facebook_client_token" translatable="false">CHANGE-ME</string>
</resources>

Consultez la documentation Facebook for Developers pour obtenir des instructions de configuration.

Autres fournisseurs

Les fournisseurs Twitter, GitHub, Microsoft, Yahoo et Apple nécessitent une configuration dans la console Firebase, mais aucune configuration Android supplémentaire. Consultez la documentation Firebase Authentication pour obtenir des instructions spécifiques aux fournisseurs.

Choisissez les fournisseurs que vous souhaitez inclure dans authUIConfiguration :

val configuration = authUIConfiguration {
    context = applicationContext
    providers {
        provider(AuthProvider.Email())
        provider(
            AuthProvider.Phone(
                defaultCountryCode = "US",
            )
        )
        provider(
            AuthProvider.Google(
                scopes = listOf("email"),
                serverClientId = null,
            )
        )
        provider(AuthProvider.Facebook())
    }
}

La connexion par lien envoyé par e-mail se trouve dans la configuration du fournisseur de messagerie :

val configuration = authUIConfiguration {
    context = applicationContext
    providers {
        provider(
            AuthProvider.Email(
                isEmailLinkSignInEnabled = true,
                emailLinkActionCodeSettings = actionCodeSettings {
                    url = "https://example.com/auth"
                    handleCodeInApp = true
                    setAndroidPackageName(
                        "com.example.app",
                        true,
                        null,
                    )
                },
            )
        )
    }
}

Pour connaître l'intégralité du flux de gestion des liens profonds, consultez la section Connexion avec un lien envoyé par e-mail du fichier README sur GitHub.

Se connecter

Créez un AuthUIConfiguration, puis affichez FirebaseAuthScreen.

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val authUI = FirebaseAuthUI.getInstance()

        setContent {
            MyAppTheme {
                val configuration = authUIConfiguration {
                    context = applicationContext
                    theme = AuthUITheme.fromMaterialTheme()
                    providers {
                        provider(AuthProvider.Email())
                        provider(
                            AuthProvider.Google(
                                scopes = listOf("email"),
                                serverClientId = null,
                            )
                        )
                    }
                }

                if (authUI.isSignedIn()) {
                    HomeScreen()
                } else {
                    FirebaseAuthScreen(
                        configuration = configuration,
                        authUI = authUI,
                        onSignInSuccess = { result ->
                            // User signed in successfully
                        },
                        onSignInFailure = { exception ->
                            // Sign in failed
                        },
                        onSignInCancelled = {
                            finish()
                        },
                    )
                }
            }
        }
    }
}

Vous bénéficiez ainsi d'un flux d'authentification complet avec :

  • Authentification par mot de passe.
  • Google Sign-In
  • Réinitialisation du mot de passe.
  • Style Material 3.
  • Prise en charge de Credential Manager.
  • Gestion des erreurs via des rappels directs.

Se déconnecter

FirebaseUI Auth fournit des méthodes pratiques pour la déconnexion et la suppression de compte :

lifecycleScope.launch {
    FirebaseAuthUI.getInstance().signOut(applicationContext)
}

lifecycleScope.launch {
    FirebaseAuthUI.getInstance().delete(applicationContext)
}

Personnalisation

FirebaseUI Auth est personnalisable. La façon la plus simple de commencer est de définir un thème directement dans authUIConfiguration :

val configuration = authUIConfiguration {
    context = applicationContext
    providers {
        provider(AuthProvider.Email())
        provider(AuthProvider.Google(scopes = listOf("email"), serverClientId = null))
    }
    theme = AuthUITheme.Adaptive
}

Vous pouvez également :

  • Utilisez AuthUITheme.Default, AuthUITheme.DefaultDark ou AuthUITheme.Adaptive.
  • Héritez du thème de votre application avec AuthUITheme.fromMaterialTheme().
  • Personnalisez le thème par défaut avec .copy().
  • Créez un AuthUITheme entièrement personnalisé.
  • Définissez un logo, l'URL des conditions d'utilisation et l'URL des règles de confidentialité dans authUIConfiguration.

Pour en savoir plus sur les thèmes et la personnalisation, y compris sur la priorité des thèmes, le style des boutons du fournisseur et les thèmes personnalisés, consultez la section Thèmes et personnalisation du fichier README sur GitHub.

Applications existantes basées sur l'activité

Si votre application utilise toujours des activités et l'API Activity Result, vous pouvez conserver un flux de lancement basé sur les activités en utilisant AuthFlowController :

private val authLauncher = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult(),
) { result ->
    if (result.resultCode == RESULT_OK) {
        val user = FirebaseAuth.getInstance().currentUser
        // ...
    } else {
        // User cancelled or sign-in failed
    }
}

val configuration = authUIConfiguration {
    context = applicationContext
    providers {
        provider(AuthProvider.Email())
        provider(
            AuthProvider.Google(
                scopes = listOf("email"),
                serverClientId = null,
            )
        )
    }
}

val controller = FirebaseAuthUI.getInstance().createAuthFlow(configuration)
authLauncher.launch(controller.createIntent(this))