Łatwe logowanie w aplikacji na Androida za pomocą FirebaseUI

FirebaseUI to biblioteka zbudowana na pakiecie SDK uwierzytelniania Firebase, która udostępnia w aplikacji procesy interfejsu użytkownika. FirebaseUI zapewnia następujące korzyści:

• Wielu dostawców – procesy logowania dla adresu e-mail i hasła, linku do adresu e-mail, uwierzytelniania przez telefon, logowania przez Google, logowania na Facebooku, logowania na Twitterze i logowania GitHuba.
• Zarządzanie kontem – umożliwia obsługę zadań związanych z zarządzaniem kontem, takich jak tworzenie konta i resetowanie haseł.
• Łączenie kont – to sposób na bezpieczne łączenie kont użytkowników z różnymi dostawcami tożsamości.
• Uaktualnianie anonimowych użytkowników – proces bezpiecznego uaktualniania anonimowych użytkowników.
• Motywy niestandardowe – dostosuj wygląd FirebaseUI do swojej aplikacji. Poza tym FirebaseUI to oprogramowanie open source, możesz więc utworzyć rozwidlenie projektu i dostosować go do swoich potrzeb.
• Smart Lock na hasła – automatyczna integracja z Smart Lock na hasła, aby szybko logować się na różnych urządzeniach.

Zanim zaczniesz

1. Dodaj Firebase do swojego projektu na Androida, jeśli jeszcze go nie masz.

2. Dodaj zależności dla FirebaseUI do pliku build.gradle na poziomie aplikacji. Jeśli chcesz obsługiwać logowanie się przez Facebooka i Twittera, dołącz też pakiety SDK Facebooka i Twittera:

   dependencies {
       // ...
   
       implementation 'com.firebaseui:firebase-ui-auth:7.2.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 uwierzytelniania FirebaseUI korzysta z przechodnich zależności od pakietu SDK Firebase i pakietu SDK Usług Google Play.

3. W konsoli Firebase otwórz sekcję Uwierzytelnianie i włącz metody logowania, które chcesz obsługiwać. Niektóre metody logowania wymagają dodatkowych informacji, które zwykle są dostępne w konsoli programisty usługi.

4. Jeśli masz włączone Logowanie przez Google:

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

   2. Przenieś ten zaktualizowany plik konfiguracji do projektu Android Studio, zastępując nieaktualny plik konfiguracji. (Przeczytaj artykuł Dodawanie Firebase do projektu na Androida).

   3. Jeśli odcisk cyfrowy SHA aplikacji nie został jeszcze określony, możesz to zrobić na stronie Ustawienia w konsoli Firebase. Szczegółowe informacje o tym, jak pobrać odcisk cyfrowy SHA aplikacji, znajdziesz w sekcji Authenticating Your Client (Uwierzytelnianie klienta).

5. Jeśli obsługujesz logowanie się przez Facebooka lub Twittera, dodaj do strings.xml zasoby w postaci ciągu znaków, które określają dane identyfikacyjne 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 w związku z umową dotyczącą wyniku działania FirebaseUI:

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

// 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);
            }
        }
);
FirebaseUIActivity.java

Aby uruchomić proces logowania się za pomocą FirebaseUI, utwórz intencję logowania za pomocą preferowanych metod logowania:

// 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)
FirebaseUIActivity.kt

// 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);
FirebaseUIActivity.java

Po zakończeniu procesu logowania otrzymasz wynik w aplikacji onSignInResult:

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

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

Skonfiguruj metody logowania

Uwierzytelnianie linków e-mail

1. W konsoli Firebase otwórz sekcję Uwierzytelnianie. Na karcie Metoda logowania włącz dostawcę E-mail/hasło. Pamiętaj, że aby skorzystać z logowania się za pomocą linku w e-mailu, musisz włączyć logowanie się przy użyciu adresu e-mail lub hasła.

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

3. Aby korzystać z logowania się za pomocą linku z e-maila, musisz też włączyć Linki dynamiczne Firebase. W konsoli Firebase w sekcji Zaangażowanie na pasku nawigacyjnym kliknij Linki dynamiczne. Kliknij Pierwsze kroki i dodaj domenę. Domena, którą tu wybierzesz, zostanie uwzględniona w linkach do e-maili wysyłanych do Twoich użytkowników.

4. Możesz włączyć logowanie w FirebaseUI przy użyciu linku e-mail, wywołując enableEmailLinkSignIn w instancji EmailBuilder. Musisz też podać prawidłowy obiekt ActionCodeSettings z parametrem setHandleCodeInApp ustawionym na wartość true. Musisz też dodać do białej listy adres URL przekazywany do setUrl. Możesz to zrobić w konsoli Firebase w sekcji Uwierzytelnianie -> Metody logowania -> Autoryzowane domeny.

   Kotlin+KTX

   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)
   FirebaseUIActivity.kt

   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);
   FirebaseUIActivity.java

5. Jeśli chcesz kliknąć link podczas konkretnego działania, wykonaj czynności opisane tutaj. W przeciwnym razie link przekieruje Cię do aktywności programu uruchamiającego.

6. Gdy znajdziesz precyzyjny link, musisz zadzwonić do nas, aby potwierdzić, że możemy go dla Ciebie obsłużyć. Jeśli to możliwe, przekaż nam je za pomocą setEmailLink.

   Kotlin+KTX

   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)
       }
   }
   FirebaseUIActivity.kt

   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);
       }
   }
   FirebaseUIActivity.java

7. Opcjonalne Domyślnie włączona jest obsługa wielu urządzeń. Możesz go wyłączyć, wywołując setForceSameDevice w instancji EmailBuilder.

   Więcej informacji znajdziesz na stronach FirebaseUI-Web i FirebaseUI-iOS.

Wyloguj się

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

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

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

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

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

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

Dostosowanie

Domyślnie FirebaseUI korzysta z AppCompat na potrzeby tworzenia motywów, co oznacza, że automatycznie przyjmie schemat kolorów Twojej aplikacji. Jeśli potrzebujesz dalszego dostosowania, możesz przekazać motyw i logo do kreatora Intent logowania:

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)
FirebaseUIActivity.kt

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);
FirebaseUIActivity.java

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

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

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

Następne kroki

• Więcej informacji o używaniu i dostosowywaniu FirebaseUI znajdziesz w README na GitHubie.
• Jeśli znajdziesz problem w FirebaseUI i chcesz go zgłosić, skorzystaj z narzędzia do śledzenia błędów na GitHubie.