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 à utiliser dans 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 des activités.

FirebaseUI Auth présente les avantages suivants :

  • Plusieurs fournisseurs : flux de connexion pour les adresses e-mail/mots de passe, les numéros de téléphone, Google, Facebook, Apple, GitHub, Microsoft, Yahoo, Twitter, l'authentification anonyme et OAuth personnalisé.
  • Gestion des comptes : flux permettant de gérer les tâches de gestion des comptes, telles que la création de comptes et la réinitialisation des mots de passe.
  • Association de comptes : flux permettant d'associer en toute sécurité des comptes utilisateur à différents fournisseurs d'identité.
  • Mise à niveau des utilisateurs anonymes : flux permettant de mettre à niveau en toute sécurité les utilisateurs anonymes.
  • Thèmes personnalisés : compatibilité avec l'UI Material 3 pouvant hériter du thème de votre application. De plus, comme FirebaseUI est Open Source, vous pouvez créer un fork du projet et le personnaliser exactement selon vos besoins.
  • Gestionnaire d'identifiants : intégration automatique au Gestionnaire d'identifiants pour une connexion rapide sur plusieurs appareils.
  • Authentification multifacteur : compatibilité avec les SMS et les TOTP pour une sécurité accrue.

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 à votre module d'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 plug-in Gradle google-services. Assurez-vous d'avoir activé Google Sign-In dans la console Firebase.

Facebook Login

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>

Pour obtenir des instructions de configuration, consultez la documentation Facebook for Developers.

Autres fournisseurs

Les fournisseurs Twitter, GitHub, Microsoft, Yahoo et Apple nécessitent une configuration dans la console Firebase, mais aucune configuration supplémentaire spécifique à Android. Pour obtenir des instructions spécifiques à chaque fournisseur, consultez la documentation Firebase Auth.

Choisissez les fournisseurs de votre choix 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 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 obtenir le flux complet de gestion des liens profonds, consultez la section Connexion par lien e-mail du fichier README dans GitHub.

Se connecter

Créez une 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 obtenez ainsi 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 comptes :

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

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

Personnalisation

FirebaseUI Auth est personnalisable. Pour commencer, le plus simple 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 :

  • Utiliser AuthUITheme.Default, AuthUITheme.DefaultDark ou AuthUITheme.Adaptive.
  • Hériter du thème de votre application avec AuthUITheme.fromMaterialTheme().
  • Personnaliser le thème par défaut avec .copy().
  • Créer un AuthUITheme entièrement personnalisé.
  • Définir un logo, une URL des conditions d'utilisation et une URL des règles de confidentialité dans authUIConfiguration.

Pour obtenir des informations complètes sur la personnalisation et la création de thèmes, y compris sur la priorité des thèmes, le style des boutons de fournisseur et les thèmes personnalisés, consultez la section Thèmes et personnalisation du fichier README dans GitHub.

Applications existantes basées sur des activités

Si votre application utilise toujours des activités et l'API Activity Result, vous pouvez conserver un flux de lancement basé sur des 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))