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

FirebaseUI Auth è una libreria basata sull'SDK Firebase Authentication che fornisce flussi UI drop-in da utilizzare nella tua app.

Il flusso di accesso consigliato utilizza le schermate di Compose. Per le app che utilizzano ancora le attività, consulta la sezione App esistenti basate su attività.

FirebaseUI Auth offre i seguenti vantaggi:

  • Più provider : flussi di accesso per email/password, telefono, Google, Facebook, Apple, GitHub, Microsoft, Yahoo, Twitter, autenticazione anonima e OAuth personalizzato.
  • Gestione account : flussi per gestire le attività di gestione degli account, come la creazione di account e la reimpostazione delle password.
  • Collegamento degli account : flussi per collegare in modo sicuro gli account utente tra i provider di identità.
  • Upgrade degli utenti anonimi : flussi per eseguire l'upgrade in modo sicuro degli utenti anonimi.
  • Temi personalizzati : supporto dell'UI Material 3 che può ereditare il tema dell'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 cross-device.
  • Autenticazione a più fattori : supporto di SMS e TOTP per una maggiore sicurezza.

Prima di iniziare

  1. Se non l'hai già fatto, aggiungi Firebase al tuo progetto Android.
  2. Nella console Firebase, attiva i metodi di accesso che vuoi supportare.
  3. Aggiungi FirebaseUI Auth al modulo dell'app:
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")
}

Configurare i metodi di accesso

Accedi con Google

La configurazione di Accedi con Google viene fornita automaticamente dal plug-in Gradle google-services. Assicurati di aver attivato Accedi con Google nella console Firebase.

Accesso con Facebook

Se utilizzi l'accesso con Facebook, aggiungi il tuo ID app Facebook a 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>

Per istruzioni sulla configurazione, consulta la documentazione di Facebook for Developers.

Altri provider

I provider Twitter, GitHub, Microsoft, Yahoo e Apple richiedono la configurazione nella console Firebase, ma non è necessaria alcuna configurazione aggiuntiva specifica per Android. Per istruzioni specifiche per il provider, consulta la documentazione di Firebase Auth.

Scegli i provider che vuoi all'interno di 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())
    }
}

L'accesso tramite link via email si trova nella configurazione del provider di posta elettronica:

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

Per il flusso completo di gestione dei link diretti, consulta la sezione Accesso tramite link via email del file README su GitHub.

Accedi

Crea un AuthUIConfiguration, quindi mostra 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()
                        },
                    )
                }
            }
        }
    }
}

In questo modo avrai un flusso di autenticazione completo con:

  • Autenticazione password.
  • Accedi con Google.
  • Reimpostazione password.
  • Stile Material 3.
  • Supporto di Gestore delle credenziali.
  • Gestione degli errori tramite callback diretti.

Esci

FirebaseUI Auth fornisce metodi pratici per la disconnessione e l'eliminazione dell'account:

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

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

Personalizzazione

FirebaseUI Auth è personalizzabile e il modo più semplice per iniziare è impostare un tema direttamente in authUIConfiguration:

val configuration = authUIConfiguration {
    context = applicationContext
    providers {
        provider(AuthProvider.Email())
        provider(AuthProvider.Google(scopes = listOf("email"), serverClientId = null))
    }
    theme = AuthUITheme.Adaptive
}

Inoltre puoi:

  • Utilizzare AuthUITheme.Default, AuthUITheme.DefaultDark o AuthUITheme.Adaptive.
  • Ereditare il tema dell'app con AuthUITheme.fromMaterialTheme().
  • Personalizzare il tema predefinito con .copy().
  • Creare un AuthUITheme completamente personalizzato.
  • Impostare un logo, l'URL dei Termini di servizio e l'URL delle norme sulla privacy in authUIConfiguration.

Per tutti i dettagli su temi e personalizzazione, inclusi la precedenza dei temi, lo stile dei pulsanti del provider e i temi personalizzati, consulta la sezione Temi e personalizzazione del file README su GitHub.

App esistenti basate su attività

Se la tua app utilizza ancora le attività e l'API Activity Result, puoi mantenere un flusso di avvio basato sulle attività utilizzando 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))