Łatwo dodaj logowanie do aplikacji na Androida za pomocą FirebaseUI

FirebaseUI to biblioteka zbudowana na podstawie pakietu SDK Firebase Authentication, która udostępnia przepływy interfejsu użytkownika do użytku w Twojej aplikacji. FirebaseUI zapewnia następujące korzyści:

• Wielu dostawców - przepływy logowania dla adresu e-mail / hasła, łącza e-mail, uwierzytelniania telefonicznego, logowania Google, logowania na Facebooku, logowania na Twitterze i logowania do GitHub.
• Zarządzanie kontami - przepływy do obsługi zadań związanych z zarządzaniem kontem, takich jak tworzenie konta i resetowanie haseł.
• Łączenie kont - przepływy do bezpiecznego łączenia kont użytkowników między dostawcami tożsamości.
• Aktualizacja anonimowych użytkowników - przepływy do bezpiecznego aktualizowania anonimowych użytkowników.
• Niestandardowe motywy - dostosuj wygląd FirebaseUI do swojej aplikacji. Ponadto, ponieważ FirebaseUI jest oprogramowaniem typu open source, możesz rozwidlić projekt i dostosować go dokładnie do swoich potrzeb.
• Smart Lock for Passwords - automatyczna integracja ze Smart Lock for Passwords dla szybkiego logowania na różnych urządzeniach.

Zanim zaczniesz

1. Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu na Androida .

2. Dodaj zależności dla FirebaseUI do pliku build.gradle poziomie aplikacji. Jeśli chcesz obsługiwać logowanie za pomocą Facebooka lub Twittera, dołącz także zestawy SDK Facebook i Twitter:

   dependencies {
       // ...
   
       implementation 'com.firebaseui:firebase-ui-auth:6.4.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:4.x'
   
       // Required only if Twitter login support is required
       // Find the latest Twitter SDK releases here: https://goo.gl/E5wZvQ
       implementation 'com.twitter.sdk.android:twitter-core:3.x'
   }
   

   Pakiet FirebaseUI Auth SDK ma przechodnie zależności od Firebase SDK i Google Play Services SDK.

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, zwykle dostępnych w konsoli programisty usługi.

4. Jeśli obsługujesz Logowanie przez Google i nie określono jeszcze odcisku palca SHA-1 aplikacji, zrób to na stronie Ustawienia w konsoli Firebase. Zobacz Uwierzytelnianie klienta, aby uzyskać szczegółowe informacje na temat uzyskiwania odcisku palca SHA-1 aplikacji.

5. Jeśli obsługujesz logowanie za pomocą Facebooka lub Twittera, dodaj zasoby ciągów do strings.xml które określają informacje 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>
     <!-- Twitter consumer key and secret -->
     <string name="twitter_consumer_key" translatable="false">YOUR_CONSUMER_KEY</string>
     <string name="twitter_consumer_secret" translatable="false">YOUR_CONSUMER_SECRET</string>
   </resources>
   

Zaloguj się

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

// 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
startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .build(),
        RC_SIGN_IN);
FirebaseUIActivity.java

// 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
startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .build(),
        RC_SIGN_IN)
FirebaseUIActivity.kt

Po zakończeniu procesu logowania otrzymasz wynik w postaci onActivityResult :

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    if (requestCode == RC_SIGN_IN) {
        IdpResponse response = IdpResponse.fromResultIntent(data);

        if (resultCode == 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

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)

    if (requestCode == RC_SIGN_IN) {
        val response = IdpResponse.fromResultIntent(data)

        if (resultCode == Activity.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

Skonfiguruj metody logowania

Uwierzytelnianie łącza e-mail

1. W konsoli Firebase otwórz sekcję Uwierzytelnianie . Na karcie Metoda logowania włącz dostawcę adresu e-mail / hasła . Należy pamiętać, że logowanie za pomocą adresu e-mail / hasła musi być włączone, aby można było korzystać z logowania za pomocą łącza e-mail.

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

3. Konieczne będzie również włączenie funkcji Łącza dynamiczne Firebase, aby korzystać z logowania przez e-mail. W konsoli Firebase kliknij łącze Dynamiczne w sekcji Zaangażuj na pasku nawigacyjnym. Kliknij Pierwsze kroki i dodaj domenę. Domena, którą tutaj wybierzesz, zostanie odzwierciedlona w linkach e-mailowych wysyłanych do użytkowników.

4. Możesz włączyć logowanie za pomocą linku e-mail w enableEmailLinkSignIn wywołując enableEmailLinkSignIn EmailBuilder instancji EmailBuilder . Potrzebny będzie również zapewnienie prawidłowego ActionCodeSettings obiekt z setHandleCodeInApp wartość true. Dodatkowo musisz dodać do białej listy adres URL, który przekazujesz do setUrl , co można zrobić w konsoli setUrl , w sekcji Uwierzytelnianie -> Metody logowania -> Autoryzowane domeny.

   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();
   
   startActivityForResult(
           AuthUI.getInstance()
                   .createSignInIntentBuilder()
                   .setAvailableProviders(Arrays.asList(
                           new AuthUI.IdpConfig.EmailBuilder().enableEmailLinkSignIn()
                           .setActionCodeSettings(actionCodeSettings).build())
                   .build(),
           RC_SIGN_IN);
   
   

5. Jeśli chcesz złapać link w określonej czynności, wykonaj kroki opisane tutaj . W przeciwnym razie łącze przekieruje do Twojej aktywności programu uruchamiającego.

6. Po złapaniu precyzyjnego linku musisz zadzwonić w celu sprawdzenia, czy możemy go dla Ciebie obsłużyć. Jeśli możemy, musisz nam to przekazać za pośrednictwem setEmailLink .

   if (AuthUI.canHandleIntent(getIntent())) {
       if (getIntent().getExtras() == null) {
               return;
           }
           String link = getIntent().getExtras().getString(ExtraConstants.EMAIL_LINK_SIGN_IN);
           if (link != null) {
               startActivityForResult(
                       AuthUI.getInstance()
                               .createSignInIntentBuilder()
                               .setEmailLink(link)
                               .setAvailableProviders(getAvailableProviders())
                               .build(),
                       RC_SIGN_IN);
           }
   }
   

7. Obsługiwane jest opcjonalne logowanie za pomocą linku e-mail między urządzeniami, co oznacza, że ​​łącze wysłane za pośrednictwem aplikacji na Androida może być używane do logowania się w aplikacjach internetowych lub iOS. Domyślnie obsługa wielu urządzeń jest włączona. Możesz go wyłączyć, wywołując setForceSameDevice w wystąpieniu EmailBuilder .

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

Wyloguj się

FirebaseUI zapewnia wygodne metody wylogowania się z Firebase Authentication oraz wszystkich dostawców tożsamości społecznościowych:

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

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

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

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

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

Dostosowywanie

Domyślnie FirebaseUI używa do tworzenia motywów AppCompat, co oznacza, że ​​w naturalny sposób przyjmie schemat kolorów Twojej aplikacji. Jeśli potrzebujesz dalszych dostosowań, możesz przekazać motyw i logo do Intent logowania:

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setLogo(R.drawable.my_great_logo)      // Set logo drawable
                .setTheme(R.style.MySuperAppTheme)      // Set theme
                .build(),
        RC_SIGN_IN);
FirebaseUIActivity.java

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setLogo(R.drawable.my_great_logo) // Set logo drawable
                .setTheme(R.style.MySuperAppTheme) // Set theme
                .build(),
        RC_SIGN_IN)
FirebaseUIActivity.kt

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

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setTosAndPrivacyPolicyUrls(
                        "https://example.com/terms.html",
                        "https://example.com/privacy.html")
                .build(),
        RC_SIGN_IN);
FirebaseUIActivity.java

startActivityForResult(
        AuthUI.getInstance()
                .createSignInIntentBuilder()
                .setAvailableProviders(providers)
                .setTosAndPrivacyPolicyUrls(
                        "https://example.com/terms.html",
                        "https://example.com/privacy.html")
                .build(),
        RC_SIGN_IN)
FirebaseUIActivity.kt

Następne kroki

• Więcej informacji o używaniu i dostosowywaniu FirebaseUI znajdziesz w pliku README w GitHub.
• Jeśli znajdziesz problem w FirebaseUI i chcesz go zgłosić, użyj narzędzia do śledzenia problemów GitHub .