Łatwe logowanie się w aplikacji na Androida dzięki FirebaseUI

FirebaseUI Auth to biblioteka oparta na pakiecie SDK uwierzytelniania Firebase, która udostępnia gotowe przepływy interfejsu do użycia w aplikacji.

Zalecany przepływ logowania korzysta z ekranów Compose. W przypadku aplikacji, które nadal używają aktywności, zapoznaj się z sekcją Aplikacje oparte na aktywności.

FirebaseUI Auth zapewnia te korzyści:

  • Wielu dostawców – przepływy logowania za pomocą adresu e-mail i hasła, telefonu, Google, Facebooka, Apple, GitHub, Microsoft, Yahoo, Twitter, uwierzytelniania anonimowego i niestandardowego OAuth.
  • Zarządzanie kontem – przepływy do obsługi zadań związanych z zarządzaniem kontem, takich jak tworzenie konta i resetowanie hasła.
  • Łączenie kont – przepływy umożliwiające bezpieczne łączenie kont użytkowników u różnych dostawców tożsamości.
  • Uaktualnianie użytkowników anonimowych – przepływy umożliwiające bezpieczne uaktualnianie użytkowników anonimowych.
  • Motywy niestandardowe – obsługa interfejsu Material 3, który może dziedziczyć motyw aplikacji. Ponadto, ponieważ FirebaseUI jest oprogramowaniem open source, możesz utworzyć fork projektu i dostosować go do swoich potrzeb.
  • Credential Manager – automatyczna integracja z Credential Manager umożliwiająca szybkie logowanie na różnych urządzeniach.
  • Uwierzytelnianie wielopoziomowe – obsługa SMS-ów i TOTP w celu zwiększenia bezpieczeństwa.

Zanim zaczniesz

  1. Jeśli jeszcze tego nie zrobisz, dodaj Firebase do projektu aplikacji na Androida.
  2. W konsoli Firebase włącz metody logowania, które chcesz obsługiwać.
  3. Dodaj FirebaseUI Auth do modułu aplikacji:
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")
}

Konfigurowanie metod logowania

Logowanie przez Google

Konfiguracja logowania przez Google jest automatycznie udostępniana przez wtyczkę Gradle google-services. Sprawdź, czy logowanie przez Google jest włączone w konsoli Firebase.

Logowanie przez Facebooka

Jeśli używasz logowania przez Facebooka, dodaj identyfikator aplikacji Facebooka do pliku 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>

Instrukcje konfiguracji znajdziesz w dokumentacji Facebooka dla deweloperów.

Inni usługodawcy

Usługodawcy Twitter, GitHub, Microsoft, Yahoo i Apple wymagają konfiguracji w konsoli Firebase, ale nie wymagają dodatkowej konfiguracji na Androidzie. Instrukcje dotyczące poszczególnych usługodawców znajdziesz w dokumentacji uwierzytelniania Firebase.

Wybierz dostawców, których chcesz używać, w 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())
    }
}

Logowanie za pomocą linku w e-mailu znajduje się w konfiguracji dostawcy poczty e-mail:

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

Pełny przepływ obsługi linków bezpośrednich znajdziesz w sekcji Logowanie za pomocą linku w e-mailu w pliku README w GitHub.

Zaloguj się

Utwórz AuthUIConfiguration, a następnie wyświetl 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()
                        },
                    )
                }
            }
        }
    }
}

Dzięki temu uzyskasz pełny przepływ uwierzytelniania z tymi funkcjami:

  • Uwierzytelnianie za pomocą hasła.
  • Logowanie przez Google.
  • Resetowanie hasła.
  • Stylizacja Material 3.
  • Obsługa Credential Manager.
  • Obsługa błędów za pomocą bezpośrednich wywołań zwrotnych.

Wyloguj się

FirebaseUI Auth udostępnia wygodne metody wylogowywania i usuwania konta:

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

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

Dostosowywanie

FirebaseUI Auth można dostosować. Najprostszym sposobem na rozpoczęcie jest ustawienie motywu bezpośrednio w authUIConfiguration:

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

Możesz też:

  • Użyj AuthUITheme.Default, AuthUITheme.DefaultDark, lub AuthUITheme.Adaptive.
  • Dziedzicz motyw aplikacji za pomocą AuthUITheme.fromMaterialTheme().
  • Dostosuj motyw domyślny za pomocą .copy().
  • Utwórz w pełni niestandardowy AuthUITheme.
  • Ustaw logo, adres URL Warunków korzystania z usługi i adres URL Polityki prywatności w authUIConfiguration.

Szczegółowe informacje o motywach i dostosowywaniu, w tym o pierwszeństwie motywów, stylizacji przycisków dostawców i motywach niestandardowych, znajdziesz w sekcji Motywy i dostosowywanie w pliku README w GitHub.

Opublikowane aplikacje

Jeśli Twoja aplikacja nadal używa aktywności i interfejsu Activity Result API, możesz zachować przepływ uruchamiania oparty na aktywności, używając 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))