Ajoutez facilement une connexion à votre application Android avec FirebaseUI

FirebaseUI est une bibliothèque en plus du SDK Firebase Authentication qui fournit des flux d'interface utilisateur prêts à l'emploi dans votre application. FirebaseUI offre les avantages suivants:

  • Fournisseurs multiples : procédures de connexion par adresse e-mail/mot de passe, lien de messagerie et numéro de téléphone Google Sign-In, Facebook, Twitter et GitHub.
  • Gestion des comptes : flux permettant de gérer les tâches de gestion des comptes, telles que la création de compte et la réinitialisation de mots de passe.
  • Association de comptes : procédure permettant d'associer de façon sécurisée les comptes utilisateur dans toutes les identités fournisseurs de services cloud.
  • Mise à niveau des utilisateurs anonymes : permet de mettre à niveau les utilisateurs anonymes de manière sécurisée.
  • Custom Themes (Thèmes personnalisés) : personnalisez l'apparence de FirebaseUI en fonction de votre application. Par ailleurs, Comme FirebaseUI est Open Source, vous pouvez dupliquer le projet et le personnaliser exactement à vos besoins.
  • Smart Lock pour les mots de passe : intégration automatique avec Smart Lock pour les mots de passe pour une connexion rapide entre les appareils.

Avant de commencer

  1. Si ce n'est 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 le 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 l'option les méthodes de connexion que vous souhaitez prendre en charge. Certaines méthodes de connexion nécessitent d'autres informations, généralement disponibles sur le site du développeur console.

  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 sur le client OAuth requise pour se connecter à 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 à partir de la Page des paramètres de la console Firebase. Pour savoir comment obtenir l'empreinte SHA de votre application, consultez Authentifier votre client.

  5. Si la connexion via Facebook ou Twitter est possible, 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éer un ActivityResultLauncher qui enregistre un rappel pour FirebaseUI Contrat de résultat d'activité:

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 un intent de connexion avec votre méthodes de connexion à privilégier:

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 la procédure de connexion terminée, 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 des méthodes de connexion

  1. Dans la console Firebase, ouvrez la section Authentification. Le l'onglet Mode de connexion, activez le fournisseur Adresse e-mail/Mot de passe. Remarque la connexion par e-mail/mot de passe doit être activée pour pouvoir utiliser la connexion par lien par e-mail.

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

  3. Vous devez également activer Firebase Dynamic Links pour utiliser la connexion par lien e-mail. Dans Dans la console Firebase, cliquez sur Liens dynamiques sous Engager dans la barre de navigation. Cliquez sur Premiers pas, puis ajoutez un domaine. Le domaine que vous choisissez ici sera reflété dans l'e-mail de liens envoyés à vos utilisateurs.

  4. Vous pouvez activer la connexion par lien d'e-mail dans FirebaseUI en appelant enableEmailLinkSignIn sur un EmailBuilder instance. Vous devez également fournir un objet ActionCodeSettings valide avec setHandleCodeInApp défini sur "true". Vous devez également ajouter l'URL que vous transmettez à setUrl à la liste blanche. Pour ce faire, accédez à la console Firebase, sous Authentication -> Sign in Methods -> Authorized domains.

    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 cette procédure. Sinon, le lien rediriger vers votre activité de lanceur d'applications.

  6. Une fois que vous avez détecté le lien profond, vous devez nous appeler pour nous assurer que nous pouvons le gérer. Si nous vous devez ensuite nous la 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. Facultatif : La connexion via un lien inter-appareil par e-mail est acceptée, ce qui signifie que le lien envoyé via votre application Android peut être utilisée pour vous connecter à vos applications Web ou Apple. Par défaut, la compatibilité multi-appareil est activé. 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 ainsi que tous les fournisseurs d'identité de réseau social:

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 thématisation, ce qui signifie qu'il à adopter le jeu de couleurs de votre application. Si vous avez besoin d'une personnalisation plus poussée, Transmettez un thème et un logo au générateur Intent de 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 des règles 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

Étapes suivantes

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