Ta strona została przetłumaczona przez Cloud Translation API.

Uwierzytelnij się za pomocą GitHub na Androidzie

Możesz umożliwić użytkownikom uwierzytelnianie w Firebase przy użyciu ich kont GitHub, integrując ogólne internetowe logowanie OAuth ze swoją aplikacją za pomocą pakietu Firebase SDK, aby przeprowadzić pełny proces logowania.

Zanim zaczniesz

Aby logować użytkowników przy użyciu kont GitHub, musisz najpierw włączyć GitHub jako dostawcę logowania do projektu Firebase:

Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu na Androida .
W konsoli Firebase otwórz sekcję Auth .
Na karcie Metoda logowania włącz dostawcę GitHub .
Dodaj identyfikator klienta i klucz tajny klienta z konsoli programisty tego dostawcy do konfiguracji dostawcy:
1. Zarejestruj swoją aplikację jako aplikację deweloperską w GitHub i uzyskaj identyfikator klienta OAuth 2.0 oraz klucz tajny klienta .
2. Upewnij się, że identyfikator URI przekierowania Firebase OAuth (np my-app-12345.firebaseapp.com/__/auth/handler ) jest ustawiony jako adres URL wywołania zwrotnego autoryzacji na stronie ustawień aplikacji w konfiguracji aplikacji GitHub .
Kliknij Zapisz .
W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle ) dodaj zależność dla biblioteki Firebase Authentication dla systemu Android. Zalecamy używanie Firebase Android BoM do kontrolowania wersji bibliotek.
Java
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:31.1.0')

    // Add the dependency for the Firebase Authentication library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-auth'
}
```
Korzystając z Firebase Android BoM , Twoja aplikacja będzie zawsze używać zgodnych wersji bibliotek Firebase na Androida.
(Alternatywnie) Dodaj zależności biblioteki Firebase bez korzystania z BoM
Jeśli zdecydujesz się nie korzystać z BoM Firebase, musisz określić każdą wersję biblioteki Firebase w jej wierszu zależności.
Pamiętaj, że jeśli korzystasz z wielu bibliotek Firebase w swojej aplikacji, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji.
```
dependencies {
    // Add the dependency for the Firebase Authentication library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-auth:21.1.0'
}
```
Kotlin+KTX
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:31.1.0')

    // Add the dependency for the Firebase Authentication library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-auth-ktx'
}
```
Korzystając z Firebase Android BoM , Twoja aplikacja będzie zawsze używać zgodnych wersji bibliotek Firebase na Androida.
(Alternatywnie) Dodaj zależności biblioteki Firebase bez korzystania z BoM
Jeśli zdecydujesz się nie korzystać z BoM Firebase, musisz określić każdą wersję biblioteki Firebase w jej wierszu zależności.
Pamiętaj, że jeśli korzystasz z wielu bibliotek Firebase w swojej aplikacji, zdecydowanie zalecamy używanie BoM do zarządzania wersjami bibliotek, co zapewnia zgodność wszystkich wersji.
```
dependencies {
    // Add the dependency for the Firebase Authentication library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-auth-ktx:21.1.0'
}
```
Jeśli nie określiłeś jeszcze odcisku cyfrowego SHA-1 swojej aplikacji, zrób to na stronie Ustawienia w konsoli Firebase. Zapoznaj się z sekcją Uwierzytelnianie klienta , aby dowiedzieć się, jak uzyskać odcisk palca SHA-1 aplikacji.

Obsługuj proces logowania za pomocą pakietu Firebase SDK

Jeśli tworzysz aplikację na Androida, najłatwiejszym sposobem uwierzytelnienia użytkowników w Firebase przy użyciu ich kont GitHub jest obsługa całego procesu logowania za pomocą pakietu Firebase Android SDK.

Aby obsłużyć proces logowania za pomocą pakietu Firebase Android SDK, wykonaj następujące czynności:

Skonstruuj wystąpienie OAuthProvider za pomocą jego Konstruktora z identyfikatorem dostawcy github.com
```
OAuthProvider.Builder provider = OAuthProvider.newBuilder("github.com");
```
Opcjonalnie : określ dodatkowe niestandardowe parametry OAuth, które chcesz wysłać z żądaniem OAuth.
```
// Target specific email with login hint.
provider.addCustomParameter("login", "your-email@gmail.com");
```
Aby uzyskać parametry obsługiwane przez GitHub, zapoznaj się z dokumentacją usługi GitHub OAuth . Pamiętaj, że za pomocą setCustomParameters() nie możesz przekazać parametrów wymaganych przez Firebase. Te parametry to client_id , response_type , redirect_uri , state , scope i response_mode .
Opcjonalnie : określ dodatkowe zakresy OAuth 2,0 poza profilem podstawowym, których chcesz zażądać od dostawcy uwierzytelniania. Jeśli Twoja aplikacja wymaga dostępu do prywatnych danych użytkownika z interfejsów API GitHub, musisz poprosić o uprawnienia dostępu do interfejsów API GitHub w sekcji Uprawnienia API w konsoli programisty GitHub. Żądane zakresy OAuth muszą dokładnie odpowiadać wstępnie skonfigurowanym zakresom w uprawnieniach interfejsu API aplikacji.
```
// Request read access to a user's email addresses.
// This must be preconfigured in the app's API permissions.
List<String> scopes =
    new ArrayList<String>() {
      {
        add("user:email");
      }
    };
provider.setScopes(scopes);
```

Uwierzytelnij się w Firebase przy użyciu obiektu dostawcy OAuth. Pamiętaj, że w przeciwieństwie do innych operacji FirebaseAuth ta funkcja przejmie kontrolę nad interfejsem użytkownika, wyświetlając niestandardową kartę Chrome . W rezultacie nie należy odwoływać się do działania w dołączonych OnSuccessListener i OnFailureListener , ponieważ zostaną one natychmiast odłączone, gdy operacja uruchomi interfejs użytkownika.

Powinieneś najpierw sprawdzić, czy otrzymałeś już odpowiedź. Zalogowanie się tą metodą umieszcza Twoją Aktywność w tle, co oznacza, że może zostać odzyskana przez system podczas procesu logowania. Aby mieć pewność, że nie zmusisz użytkownika do ponownej próby, jeśli tak się stanie, powinieneś sprawdzić, czy wynik jest już obecny.

Aby sprawdzić, czy istnieje oczekujący wynik, wywołaj getPendingAuthResult :

Task<AuthResult> pendingResultTask = firebaseAuth.getPendingAuthResult();
if (pendingResultTask != null) {
  // There's something already here! Finish the sign-in for your user.
  pendingResultTask
      .addOnSuccessListener(
          new OnSuccessListener<AuthResult>() {
            @Override
            public void onSuccess(AuthResult authResult) {
              // User is signed in.
              // IdP data available in
              // authResult.getAdditionalUserInfo().getProfile().
              // The OAuth access token can also be retrieved:
              // ((OAuthCredential)authResult.getCredential()).getAccessToken().
            }
          })
      .addOnFailureListener(
          new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
              // Handle failure.
            }
          });
} else {
  // There's no pending result so you need to start the sign-in flow.
  // See below.
}

Aby rozpocząć proces logowania, wywołaj startActivityForSignInWithProvider :

firebaseAuth
    .startActivityForSignInWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener(
        new OnSuccessListener<AuthResult>() {
          @Override
          public void onSuccess(AuthResult authResult) {
            // User is signed in.
            // IdP data available in
            // authResult.getAdditionalUserInfo().getProfile().
            // The OAuth access token can also be retrieved:
            // ((OAuthCredential)authResult.getCredential()).getAccessToken().
          }
        })
    .addOnFailureListener(
        new OnFailureListener() {
          @Override
          public void onFailure(@NonNull Exception e) {
            // Handle failure.
          }
        });

Po pomyślnym zakończeniu token dostępu OAuth skojarzony z dostawcą może zostać pobrany ze zwróconego obiektu OAuthCredential .

Korzystając z tokena dostępu OAuth, możesz wywołać interfejs API GitHub .

Na przykład, aby uzyskać podstawowe informacje o profilu, możesz wywołać REST API, przekazując token dostępu w nagłówku Authorization :

Chociaż powyższe przykłady koncentrują się na przepływach logowania, możesz również połączyć dostawcę GitHub z istniejącym użytkownikiem przy użyciu startActivityForLinkWithProvider . Na przykład możesz połączyć wielu dostawców z tym samym użytkownikiem, umożliwiając im logowanie się za pomocą jednego z nich.

// The user is already signed-in.
FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();

firebaseUser
    .startActivityForLinkWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener(
        new OnSuccessListener<AuthResult>() {
          @Override
          public void onSuccess(AuthResult authResult) {
            // GitHub credential is linked to the current user.
            // IdP data available in
            // authResult.getAdditionalUserInfo().getProfile().
            // The OAuth access token can also be retrieved:
            // authResult.getCredential().getAccessToken().
          }
        })
    .addOnFailureListener(
        new OnFailureListener() {
          @Override
          public void onFailure(@NonNull Exception e) {
            // Handle failure.
          }
        });

Ten sam wzorzec może być używany z startActivityForReauthenticateWithProvider , który może służyć do pobierania świeżych poświadczeń dla poufnych operacji, które wymagają niedawnego logowania.

// The user is already signed-in.
FirebaseUser firebaseUser = firebaseAuth.getCurrentUser();

firebaseUser
    .startActivityForReauthenticateWithProvider(/* activity= */ this, provider.build())
    .addOnSuccessListener(
        new OnSuccessListener<AuthResult>() {
          @Override
          public void onSuccess(AuthResult authResult) {
            // User is re-authenticated with fresh tokens and
            // should be able to perform sensitive operations
            // like account deletion and email or password
            // update.
          }
        })
    .addOnFailureListener(
        new OnFailureListener() {
          @Override
          public void onFailure(@NonNull Exception e) {
            // Handle failure.
          }
        });

Następne kroki

Gdy użytkownik zaloguje się po raz pierwszy, zostanie utworzone nowe konto użytkownika i połączone z poświadczeniami — czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami o dostawcy uwierzytelniania — przy użyciu których użytkownik się zalogował. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikowania użytkownika w każdej aplikacji w projekcie, niezależnie od tego, jak się on loguje.

W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu FirebaseUser . Zobacz Zarządzanie użytkownikami .
W regułach bezpieczeństwa bazy danych czasu rzeczywistego i usługi Cloud Storage Firebase możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i używać go do kontrolowania, do jakich danych użytkownik ma dostęp.

Możesz zezwolić użytkownikom na logowanie się do Twojej aplikacji przy użyciu wielu dostawców uwierzytelniania, łącząc poświadczenia dostawcy uwierzytelniania z istniejącym kontem użytkownika.

Aby wylogować użytkownika, zadzwoń do signOut :

Java

FirebaseAuth.getInstance().signOut();MainActivity.java

Kotlin+KTX

Firebase.auth.signOut()MainActivity.kt