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

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

  • Wielu dostawców – procesy logowania za pomocą adresu e-mail i hasła, linku w e-mailu, uwierzytelniania telefonicznego, logowania przez Google, Facebooka, Twittera i GitHub.
  • 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 – procesy bezpiecznego łączenia kont użytkowników u różnych dostawców tożsamości.
  • Uaktualnianie użytkowników anonimowych – przepływy bezpiecznego uaktualniania użytkowników anonimowych.
  • Własne motywy – dostosuj wygląd FirebaseUI do swojej aplikacji. Ponadto, ponieważ FirebaseUI jest projektem open source, możesz go rozwidlić i dostosować do swoich potrzeb.
  • Menedżer danych logowania – automatyczna integracja z Menedżerem danych logowania umożliwiająca szybkie logowanie na różnych urządzeniach.

Zanim zaczniesz

  1. Jeśli nie korzystasz jeszcze z Firebase, dodaj tę usługę do projektu aplikacji na Androida.

  2. Dodaj zależności FirebaseUI do pliku build.gradle(.kts)na poziomie aplikacji. Jeśli chcesz obsługiwać logowanie za pomocą Facebooka lub Twittera, uwzględnij też pakiety SDK Facebooka i Twittera:

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

    Pakiet SDK FirebaseUI Auth ma zależności przechodnie od pakietu SDK Firebase i pakietu SDK Usług Google Play.

  3. W konsoli Firebase otwórz Bezpieczeństwo > Uwierzytelnianie.

  4. Na karcie Metoda logowania włącz dostawców logowania, których chcesz obsługiwać. Niektórzy dostawcy logowania wymagają dodatkowych informacji, które zwykle są dostępne w konsoli dewelopera usługi.

  5. Jeśli włączysz Logowanie przez Google:

    1. Zaktualizuj plik konfiguracyjny Firebase.

      1. Gdy w konsoli Firebase pojawi się odpowiedni komunikat, pobierz zaktualizowany plik konfiguracyjny Firebase (google-services.json), który zawiera teraz informacje o kliencie OAuth wymagane do logowania przez Google.

      2. Przenieś zaktualizowany plik konfiguracyjny do projektu Android Studio, zastępując nim nieaktualny plik konfiguracyjny. (Patrz Dodawanie Firebase do projektu aplikacji na Androida).

    2. Określ odcisk cyfrowy SHA-1 aplikacji, jeśli nie zostało to jeszcze zrobione.

      1. W konsoli Firebase otwórz Ustawienia > kartę Ogólne.

      2. Przewiń w dół do karty Twoje aplikacje, wybierz aplikację na Androida i dodaj odcisk cyfrowy SHA-1 w polu Odciski cyfrowe certyfikatu SHA.

      Więcej informacji o tym, jak uzyskać odcisk cyfrowy SHA aplikacji, znajdziesz w sekcji Uwierzytelnianie klienta.

  6. Jeśli obsługujesz logowanie za pomocą Facebooka lub Twittera, dodaj do strings.xml zasoby tekstowe, które określają informacje umożliwiające identyfikację wymagane przez każdego dostawcę:

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

Zaloguj się

Utwórz ActivityResultLauncher, który rejestruje wywołanie zwrotne dla kontraktu wyniku działania 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);
            }
        }
);

Aby rozpocząć proces logowania w FirebaseUI, utwórz intencję logowania z wybranymi metodami logowania:

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

Po zakończeniu procesu logowania otrzymasz wynik w 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.
        // ...
    }
}

Konfigurowanie metod logowania

  1. W konsoli Firebase otwórz Zabezpieczenia > Uwierzytelnianie.

  2. Na karcie Metoda logowania włącz metodę logowania E-mail/hasło. Pamiętaj, że aby korzystać z logowania za pomocą linku w e-mailu, musisz włączyć logowanie za pomocą adresu e-mail i hasła.

  3. W tej samej sekcji włącz metodę logowania Link w e-mailu (logowanie bez hasła) i kliknij Zapisz.

  4. Aby korzystać z logowania za pomocą linku w e-mailu, musisz też włączyć Firebase Dynamic Links:

    1. W konsoli Firebase otwórz DevOps i zaangażowanie > Dynamiczne linki.

    2. Kliknij Rozpocznij, a następnie dodaj domenę. Wybrana tutaj domena będzie widoczna w linkach w e-mailach wysyłanych do użytkowników.

  5. Aby włączyć logowanie za pomocą linku w e-mailu w FirebaseUI, wywołaj funkcję enableEmailLinkSignIn na instancji EmailBuilder. Musisz też podać prawidłowy ActionCodeSettings obiekt z wartością setHandleCodeInApp ustawioną na true.

    Dodatkowo musisz dodać do białej listy adres URL przekazywany do funkcji setUrl:

    1. W konsoli Firebase otwórz kartę Zabezpieczenia > Uwierzytelnianie > Ustawienia.

    2. W sekcji Autoryzowane domeny kliknij Dodaj domenę i dodaj swoją domenę.

    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. Jeśli chcesz przechwycić link w konkretnej aktywności, wykonaj czynności opisane tutaj. W przeciwnym razie link przekieruje do aktywności programu uruchamiającego.

  7. Gdy przechwycisz precyzyjny link, musisz wywołać weryfikację, abyśmy mogli go obsłużyć. Jeśli to możliwe, musisz przesłać nam ten dokument za pomocą 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. Opcjonalnie: obsługiwane jest logowanie za pomocą linku w e-mailu na różnych urządzeniach, co oznacza, że link wysłany przez aplikację na Androida może być używany do logowania się w aplikacjach internetowych lub na urządzenia Apple. Domyślnie obsługa wielu urządzeń jest włączona. Możesz ją wyłączyć, wywołując setForceSameDevice na instancji EmailBuilder.

    Więcej informacji znajdziesz w FirebaseUI-Web i FirebaseUI-iOS.

Wyloguj się

FirebaseUI udostępnia wygodne metody wylogowywania się z usługi Uwierzytelnianie Firebase, a także ze wszystkich dostawców tożsamości społecznościowych:

Kotlin

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

Java

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

Możesz też całkowicie usunąć konto użytkownika:

Kotlin

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

Java

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

Dostosowywanie

Domyślnie FirebaseUI używa AppCompat do określania motywu, co oznacza, że naturalnie przyjmie schemat kolorów Twojej aplikacji. Jeśli potrzebujesz dalszej personalizacji, możesz przekazać motyw i logo do narzędzia do tworzenia logowania Intent:

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

Możesz też ustawić niestandardową politykę prywatności i warunki korzystania z usługi:

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

Następne kroki