Aggiungi facilmente l'accesso alla tua app per Android con FirebaseUI

FirebaseUI è una libreria basata sull'SDK Firebase Authentication che fornisce flussi UI drop-in da utilizzare nella tua app. FirebaseUI offre i seguenti vantaggi:

  • Più provider : flussi di accesso per email/password, link email, autentica zione telefonica, Accedi con Google, accesso con Facebook, accesso con Twitter e accesso con GitHub.
  • Gestione dell'account : flussi per gestire le attività di gestione dell'account, come la creazione dell'account e la reimpostazione della password.
  • Collegamento degli account - flussi per collegare in modo sicuro gli account utente tra i provider di identità.
  • Upgrade dell'utente anonimo : flussi per eseguire l'upgrade in modo sicuro degli utenti anonimi.
  • Temi personalizzati - personalizza l'aspetto di FirebaseUI in modo che corrisponda alla tua app. Inoltre, poiché FirebaseUI è open source, puoi creare un fork del progetto e personalizzarlo esattamente in base alle tue esigenze.
  • Gestore delle credenziali: integrazione automatica con Gestore delle credenziali per un accesso rapido su più dispositivi.

Prima di iniziare

  1. Se non l'hai ancora fatto, aggiungi Firebase al tuo progetto Android.

  2. Aggiungi le dipendenze per FirebaseUI al file build.gradle(.kts) a livello di app. Se vuoi supportare l'accesso con Facebook o Twitter, includi anche gli SDK di Facebook e Twitter:

        dependencies {
        // ...

        implementation("com.firebaseui:firebase-ui-auth:9.0.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")
    }

    L'SDK di autenticazione FirebaseUI ha dipendenze transitive dall'SDK Firebase e dall'SDK dei servizi Google Play.

  3. Nella console Firebase, vai a Sicurezza > Autenticazione.

  4. Nella scheda Metodo di accesso, attiva i provider di accesso che vuoi supportare. Alcuni provider di accesso richiedono informazioni aggiuntive, in genere disponibili nella console per sviluppatori del servizio.

  5. Se hai attivato Accedi con Google:

    1. Aggiorna il file di configurazione di Firebase.

      1. Quando ti viene richiesto nella console Firebase, scarica il file di configurazione di Firebase aggiornato (google-services.json), che ora contiene le informazioni del client OAuth necessarie per Accedi con Google.

      2. Sposta questo file di configurazione aggiornato nel tuo progetto Android Studio, sostituendo il file di configurazione corrispondente ormai obsoleto. (Consulta Aggiungere Firebase al progetto Android.)

    2. Specifica l'impronta SHA-1 della tua app, se non l'hai già fatto.

      1. Nella console Firebase, vai alla scheda Impostazioni > Generale.

      2. Scorri verso il basso fino alla scheda Le tue app, seleziona la tua app per Android e aggiungi l'impronta SHA-1 nel campo Impronte digitali del certificato SHA.

      Per informazioni dettagliate su come ottenere l'impronta SHA della tua app, consulta Autenticare il client.

  6. Se supporti l'accesso con Facebook o Twitter, aggiungi risorse stringa a strings.xml che specificano le informazioni identitarie richieste da ogni provider:

    
<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>

Accedi

Crea un ActivityResultLauncher che registri un callback per il contratto del risultato dell'attività FirebaseUI:

Kotlin

// See: https://developer.android.com/training/basics/intents/result
private val signInLauncher = registerForActivityResult(
    FirebaseAuthUIActivityResultContract(),
) { res ->
    this.onSignInResult(res)
}

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);
            }
        }
);

Per avviare il flusso di accesso FirebaseUI, crea un intent di accesso con i metodi di accesso che preferisci:

Kotlin

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

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);

Al termine del flusso di accesso, riceverai il risultato in onSignInResult:

Kotlin

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.
        // ...
    }
}

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.
        // ...
    }
}

Configurare i metodi di accesso

  1. Nella console Firebase, vai a Sicurezza > Autenticazione.

  2. Nella scheda Metodo di accesso, attiva il metodo di accesso Email/Password. Tieni presente che l'accesso tramite email/password deve essere attivato per utilizzare l'accesso tramite link email.

  3. Nella stessa sezione, attiva il metodo di accesso Link email (accesso senza password) e fai clic su Salva.

  4. Per utilizzare l'accesso tramite link email, devi anche attivare Firebase Dynamic Links:

    1. Nella console Firebase, vai a DevOps e coinvolgimento > Dynamic Links.

    2. Fai clic su Inizia, quindi aggiungi un dominio. Il dominio che scegli qui verrà visualizzato nei link email inviati ai tuoi utenti.

  5. Puoi attivare l'accesso tramite link email in FirebaseUI chiamando enableEmailLinkSignIn su un'istanza EmailBuilder. Dovrai anche fornire un oggetto ActionCodeSettings valido con setHandleCodeInApp impostato su true.

    Inoltre, devi inserire nella lista consentita l'URL che passi a setUrl:

    1. Nella console Firebase, vai alla scheda Sicurezza > Autenticazione > Impostazioni.

    2. Nella sezione Domini autorizzati , fai clic su Aggiungi dominio e aggiungi il tuo dominio.

    Kotlin

    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)

    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);

  6. Se vuoi intercettare il link in un'attività specifica, segui i passaggi descritti qui. In caso contrario, il link reindirizzerà all'attività di avvio.

  7. Una volta intercettato il link diretto, dovrai chiamare per verificare che possiamo gestirlo per te. Se possiamo, devi passarlo a noi tramite setEmailLink.

    Kotlin

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

    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);
    }
}

  8. Facoltativo : è supportato l'accesso tramite link email su più dispositivi, il che significa che il link inviato tramite l'app per Android può essere utilizzato per accedere alle app web o Apple. Per impostazione predefinita, il supporto su più dispositivi è attivato. Puoi disattivarlo chiamando setForceSameDevice sull'istanza EmailBuilder.

    Per ulteriori informazioni, consulta FirebaseUI-Web e FirebaseUI-iOS.

Esci

FirebaseUI fornisce metodi pratici per uscire da Firebase Authentication e da tutti i provider di identità social:

Kotlin

AuthUI.getInstance()
    .signOut(this)
    .addOnCompleteListener {
        // ...
    }

Java

AuthUI.getInstance()
        .signOut(this)
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            public void onComplete(@NonNull Task<Void> task) {
                // ...
            }
        });

Puoi anche eliminare completamente l'account dell'utente:

Kotlin

AuthUI.getInstance()
    .delete(this)
    .addOnCompleteListener {
        // ...
    }

Java

AuthUI.getInstance()
        .delete(this)
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                // ...
            }
        });

Personalizzazione

Per impostazione predefinita, FirebaseUI utilizza AppCompat per i temi, il che significa che adotterà naturalmente la combinazione di colori della tua app. Se hai bisogno di ulteriore personalizzazione, puoi passare un tema e un logo al builder Intent di accesso:

Kotlin

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)

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);

Puoi anche impostare norme sulla privacy e termini di servizio personalizzati:

Kotlin

val signInIntent = AuthUI.getInstance()
    .createSignInIntentBuilder()
    .setAvailableProviders(providers)
    .setTosAndPrivacyPolicyUrls(
        "https://example.com/terms.html",
        "https://example.com/privacy.html",
    )
    .build()
signInLauncher.launch(signInIntent)

Java

Intent signInIntent = AuthUI.getInstance()
        .createSignInIntentBuilder()
        .setAvailableProviders(providers)
        .setTosAndPrivacyPolicyUrls(
                "https://example.com/terms.html",
                "https://example.com/privacy.html")
        .build();
signInLauncher.launch(signInIntent);

Passaggi successivi

  • Per ulteriori informazioni sull'utilizzo e la personalizzazione di FirebaseUI, consulta il README file su GitHub.
  • Se riscontri un problema in FirebaseUI e vuoi segnalarlo, utilizza il tracker dei problemi di GitHub.