Google is committed to advancing racial equity for Black communities. See how.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

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 la réinitialisation de mot de passe.
  • Liaison de compte - flux pour lier en toute sécurité les comptes d'utilisateurs entre les fournisseurs d'identité.
  • Mise à niveau des utilisateurs anonymes - permet de 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 créer un fork du projet et le personnaliser exactement selon vos besoins.
  • Smart Lock for Passwords - intégration automatique avec Smart Lock for Passwords pour une connexion rapide entre 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 niveau de l' build.gradle . 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:6.4.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:4.x'
    
        // Required only if Twitter login support is required
        // Find the latest Twitter SDK releases here: https://goo.gl/E5wZvQ
        implementation 'com.twitter.sdk.android:twitter-core:3.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 la connexion à Google et que vous n'avez pas encore spécifié l'empreinte digitale SHA-1 de votre application, faites-le depuis la page Paramètres de la console Firebase. Consultez Authentification de votre client pour plus de détails sur la façon d'obtenir l'empreinte digitale 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>
      <!-- Twitter consumer key and secret -->
      <string name="twitter_consumer_key" translatable="false">YOUR_CONSUMER_KEY</string>
      <string name="twitter_consumer_secret" translatable="false">YOUR_CONSUMER_SECRET</string>
    </resources>
    

se connecter

Pour lancer le flux de connexion FirebaseUI, créez un intent 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
startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .build(),
        RC_SIGN_IN);

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
startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .build(),
        RC_SIGN_IN)

Lorsque le onActivityResult de onActivityResult est terminé, vous recevrez le résultat dans onActivityResult :

Java

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == RC_SIGN_IN) {
        IdpResponse response = IdpResponse.fromResultIntent(data);

        if (resultCode == 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

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)

    if (requestCode == RC_SIGN_IN) {
        val response = IdpResponse.fromResultIntent(data)

        if (resultCode == Activity.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 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, 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 Engager dans la barre de navigation. Cliquez sur Premiers pas 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. En outre, vous devez mettre sur 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.

    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();
    
    startActivityForResult(
            AuthUI.getInstance()
                    .createSignInIntentBuilder()
                    .setAvailableProviders(Arrays.asList(
                            new AuthUI.IdpConfig.EmailBuilder().enableEmailLinkSignIn()
                            .setActionCodeSettings(actionCodeSettings).build())
                    .build(),
            RC_SIGN_IN);
    
    
  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 avez attrapé 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 setEmailLink via setEmailLink .

    if (AuthUI.canHandleIntent(getIntent())) {
        if (getIntent().getExtras() == null) {
                return;
            }
            String link = getIntent().getExtras().getString(ExtraConstants.EMAIL_LINK_SIGN_IN);
            if (link != null) {
                startActivityForResult(
                        AuthUI.getInstance()
                                .createSignInIntentBuilder()
                                .setEmailLink(link)
                                .setAvailableProviders(getAvailableProviders())
                                .build(),
                        RC_SIGN_IN);
            }
    }
    
  7. La connexion facultative par lien de messagerie entre 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 iOS. 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 .

    Consultez 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 connexion:

Java

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setLogo(R.drawable.my_great_logo)      // Set logo drawable
                .setTheme(R.style.MySuperAppTheme)      // Set theme
                .build(),
        RC_SIGN_IN);

Kotlin + KTX

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setLogo(R.drawable.my_great_logo) // Set logo drawable
                .setTheme(R.style.MySuperAppTheme) // Set theme
                .build(),
        RC_SIGN_IN)

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

Java

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setTosAndPrivacyPolicyUrls(
                        "https://example.com/terms.html",
                        "https://example.com/privacy.html")
                .build(),
        RC_SIGN_IN);

Kotlin + KTX

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setTosAndPrivacyPolicyUrls(
                        "https://example.com/terms.html",
                        "https://example.com/privacy.html")
                .build(),
        RC_SIGN_IN)

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 l' outil de suivi des problèmes GitHub .