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 UI drop-in pour une utilisation dans votre application. FirebaseUI offre les avantages suivants :

  • Les fournisseurs multiples - inscription dans les flux pour le courrier électronique / mot de passe, lien e - mail, l' authentification de téléphone, connexion Google, Facebook Connexion, Twitter Connectez - vous et GitHub Connexion.
  • Gestion du compte - flux pour gérer les tâches de gestion de compte, tels que la création de compte et remet à zéro le mot de passe.
  • Compte Linking - flux en toute sécurité des comptes utilisateurs lien entre les fournisseurs d'identité.
  • Utilisateur anonyme Mise à niveau - flux de mise à niveau en toute sécurité des utilisateurs anonymes.
  • Thèmes personnalisés - personnaliser l'apparence de FirebaseUI pour correspondre à votre application. De plus, comme FirebaseUI est open source, vous pouvez bifurquer le projet et le personnaliser exactement selon vos besoins.
  • Smart Lock pour les mots de passe - intégration automatique avec Smart Lock pour les mots de passe pour rapide de connexion multi-appareils.

Avant que tu commences

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

  2. Ajoutez les dépendances pour FirebaseUI à votre niveau d'application build.gradle fichier. 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 l'authentification dans les méthodes que vous souhaitez soutenir. 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 soutenez session Google et n'avez pas encore précisé l'empreinte SHA-1 de votre application, faites à partir de la page Paramètres de la console Firebase. Voir Authentifier votre client pour plus de détails sur la façon d'obtenir l'empreinte SHA-1 de votre application.

  5. Si vous soutenez la connexion avec Facebook ou Twitter, ajouter 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éer un ActivityResultLauncher qui enregistre un rappel pour le contrat de résultat 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)

Lorsque le flux de connexion est terminée, 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 des méthodes de connexion

  1. Dans la console Firebase , ouvrez la section d' authentification. Sur l'onglet Connexion méthode, activez le fournisseur Email / mot de passe. Notez que la connexion par e-mail/mot de passe doit être activée pour utiliser la connexion par lien de messagerie.

  2. Dans la même section, activer la connexion méthode lien e - mail (connexion passwordless) et cliquez sur Enregistrer.

  3. Vous devrez également activer Firebase dynamique liens avec l'utilisation signe email-lien. Dans la console Firebase , cliquez sur Dynamic Links en engager dans la barre de navigation. Cliquez sur Mise en route et ajouter 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 de lien e - mail à en FirebaseUI en appelant le enableEmailLinkSignIn sur un EmailBuilder exemple. Vous devrez également fournir un valide ActionCodeSettings objet avec setHandleCodeInApp valeur true. , Vous avez besoin de plus de whitelist l'URL que vous passez à setUrl , qui peut être fait dans la console Firebase , sous Authentification -> Connexion Méthodes -> 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 voulez attraper le lien dans une activité spécifique, s'il vous plaît suivre les étapes décrites ici . Sinon, le lien redirigera 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 pouvons, vous devez nous transmettre ensuite grâce setEmailLink .

    Java

    if (AuthUI.canHandleIntent(getIntent())) {
        if (getIntent().getExtras() == null) {
            return;
        }
        String link = getIntent().getExtras().getString(ExtraConstants.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(ExtraConstants.EMAIL_LINK_SIGN_IN)
        if (link != null) {
            val signInIntent = AuthUI.getInstance()
                    .createSignInIntentBuilder()
                    .setEmailLink(link)
                    .setAvailableProviders(providers)
                    .build()
            signInLauncher.launch(signInIntent)
        }
    }
  7. Lien e - mail de l' appareil Croix en option Se connecter est pris en charge, ce qui signifie que le lien envoyé via votre application Android peut être utilisé pour se connecter sur votre web ou des applications iOS. Par défaut, la prise en charge multi-appareils est activée. Vous pouvez le désactiver en appelant setForceSameDevice sur le EmailBuilder exemple.

    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 le thème, ce qui signifie qu'il adoptera naturellement le schéma de couleurs de votre application. Si vous avez besoin d' une personnalisation plus poussée , vous pouvez passer un thème et un logo pour le signe en Intent constructeur:

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 FirebaseUI, consultez le README fichier sur GitHub.
  • Si vous trouvez un problème dans FirebaseUI et que vous souhaitez signaler, utilisez le suivi des problèmes GitHub .