Google is committed to advancing racial equity for Black communities. See how.
Ta strona została przetłumaczona przez Cloud Translation API.
Switch to English

Uwierzytelnij się za pomocą Apple i C ++

Możesz pozwolić swoim użytkownikom na uwierzytelnianie w Firebase przy użyciu ich identyfikatora Apple ID, używając pakietu SDK Firebase, aby przeprowadzić pełny proces logowania OAuth 2.0.

Zanim zaczniesz

Aby zalogować użytkowników za pomocą Apple, najpierw skonfiguruj opcję Zaloguj się za pomocą Apple w witrynie programistów Apple, a następnie włącz Apple jako dostawcę logowania do projektu Firebase.

Dołącz do programu Apple Developer

Logowanie za pomocą Apple może być skonfigurowane tylko przez członków programu Apple Developer Program .

Skonfiguruj logowanie za pomocą Apple

Apple Sign In musi być włączone i poprawnie skonfigurowane w projekcie Firebase. Konfiguracja różni się na platformach Android i iOS. Przed kontynuowaniem postępuj zgodnie z sekcją „Konfiguruj logowanie za pomocą Apple” w przewodnikach dotyczących systemu iOS i / lub Android .

Włącz Apple jako dostawcę logowania

  1. W konsoli Firebase otwórz sekcję Auth . Na karcie Metoda logowania włącz dostawcę Apple .
  2. Skonfiguruj ustawienia dostawcy Apple Sign-in:
    1. Jeśli wdrażasz swoją aplikację tylko w systemie iOS, możesz pozostawić pola Service ID, Apple Team ID, klucz prywatny i identyfikator klucza puste.
    2. Aby uzyskać pomoc na urządzeniach z systemem Android:
      1. Dodaj Firebase do swojego projektu na Androida . Pamiętaj, aby zarejestrować podpis SHA-1 swojej aplikacji podczas konfigurowania aplikacji w konsoli Firebase.
      2. W konsoli Firebase otwórz sekcję Auth . Na karcie Metoda logowania włącz dostawcę Apple . Określ identyfikator usługi utworzony w poprzedniej sekcji. Ponadto w sekcji konfiguracji przepływu kodu OAuth określ swój identyfikator zespołu Apple oraz klucz prywatny i identyfikator klucza utworzony w poprzedniej sekcji.

Przestrzegaj wymagań Apple dotyczących anonimowych danych

Sign In with Apple daje użytkownikom możliwość anonimizacji ich danych, w tym adresu e-mail, podczas logowania. Użytkownicy, którzy wybiorą tę opcję, mają adresy e-mail z domeną privaterelay.appleid.com . Korzystając z funkcji Zaloguj się przez Apple w swojej aplikacji, musisz przestrzegać wszelkich obowiązujących zasad lub warunków dla programistów Apple dotyczących tych anonimowych identyfikatorów Apple ID.

Obejmuje to uzyskanie wymaganej zgody użytkownika przed powiązaniem jakichkolwiek danych osobowych umożliwiających bezpośrednią identyfikację z anonimowym identyfikatorem Apple ID. W przypadku korzystania z uwierzytelniania Firebase może to obejmować następujące działania:

  • Połącz adres e-mail z anonimowym identyfikatorem Apple ID lub odwrotnie.
  • Połącz numer telefonu z anonimowym identyfikatorem Apple ID lub odwrotnie
  • Połącz nieanonimowe dane logowania społecznościowego (Facebook, Google itp.) Z anonimowym identyfikatorem Apple ID lub odwrotnie.

Powyższa lista nie jest wyczerpująca. Zapoznaj się z umową licencyjną programu Apple Developer w sekcji Członkostwo na koncie programisty, aby upewnić się, że aplikacja spełnia wymagania Apple.

Uzyskaj dostęp do klasy firebase::auth::Auth

Klasa Auth jest bramą dla wszystkich wywołań API.
  1. Dodaj pliki nagłówkowe uwierzytelniania i aplikacji:
    #include "firebase/app.h"
    #include "firebase/auth.h"
    
  2. W swoim kodzie inicjującym utwórz klasę firebase::App .
    #if defined(__ANDROID__)
      firebase::App* app =
          firebase::App::Create(firebase::AppOptions(), my_jni_env, my_activity);
    #else
      firebase::App* app = firebase::App::Create(firebase::AppOptions());
    #endif  // defined(__ANDROID__)
    
  3. firebase::auth::Auth klasę firebase::auth::Auth dla swojego firebase::App . Istnieje mapowanie jeden do jednego między App a Auth .
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
    

Obsługuj proces logowania za pomocą pakietu Firebase SDK

Proces logowania się do Apple różni się na różnych platformach iOS i Android.

Na iOS

Uwierzytelnij swoich użytkowników za pomocą Firebase za pomocą zestawu Apple Sign In Objective-C SDK wywołanego z kodu C ++.

  1. Dla każdego żądania logowania wygeneruj losowy ciąg - „jednorazowy” - którego użyjesz, aby upewnić się, że otrzymany token identyfikatora został przyznany w odpowiedzi na żądanie uwierzytelnienia aplikacji. Ten krok jest ważny, aby zapobiec atakom powtórkowym.

      - (NSString *)randomNonce:(NSInteger)length {
        NSAssert(length > 0, @"Expected nonce to have positive length");
        NSString *characterSet = @"0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._";
        NSMutableString *result = [NSMutableString string];
        NSInteger remainingLength = length;
    
        while (remainingLength > 0) {
          NSMutableArray *randoms = [NSMutableArray arrayWithCapacity:16];
          for (NSInteger i = 0; i < 16; i++) {
            uint8_t random = 0;
            int errorCode = SecRandomCopyBytes(kSecRandomDefault, 1, &random);
            NSAssert(errorCode == errSecSuccess, @"Unable to generate nonce: OSStatus %i", errorCode);
    
            [randoms addObject:@(random)];
          }
    
          for (NSNumber *random in randoms) {
            if (remainingLength == 0) {
              break;
            }
    
            if (random.unsignedIntValue < characterSet.length) {
              unichar character = [characterSet characterAtIndex:random.unsignedIntValue];
              [result appendFormat:@"%C", character];
              remainingLength--;
            }
          }
        }
      }
    
    

    Wraz z żądaniem logowania wyślesz skrót SHA256 wartości jednorazowej, który Apple przekaże bez zmian w odpowiedzi. Firebase sprawdza odpowiedź, haszując pierwotną wartość jednorazową i porównując ją z wartością przekazaną przez Apple.

  2. Uruchom proces logowania Apple, w tym w swoim żądaniu skrót SHA256 wartości jednorazowej i klasę delegata, która będzie obsługiwać odpowiedź Apple (zobacz następny krok):

      - (void)startSignInWithAppleFlow {
        NSString *nonce = [self randomNonce:32];
        self.currentNonce = nonce;
        ASAuthorizationAppleIDProvider *appleIDProvider = [[ASAuthorizationAppleIDProvider alloc] init];
        ASAuthorizationAppleIDRequest *request = [appleIDProvider createRequest];
        request.requestedScopes = @[ASAuthorizationScopeFullName, ASAuthorizationScopeEmail];
        request.nonce = [self stringBySha256HashingString:nonce];
    
        ASAuthorizationController *authorizationController =
            [[ASAuthorizationController alloc] initWithAuthorizationRequests:@[request]];
        authorizationController.delegate = self;
        authorizationController.presentationContextProvider = self;
        [authorizationController performRequests];
      }
    
      - (NSString *)stringBySha256HashingString:(NSString *)input {
        const char *string = [input UTF8String];
        unsigned char result[CC_SHA256_DIGEST_LENGTH];
        CC_SHA256(string, (CC_LONG)strlen(string), result);
    
        NSMutableString *hashed = [NSMutableString stringWithCapacity:CC_SHA256_DIGEST_LENGTH * 2];
        for (NSInteger i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
          [hashed appendFormat:@"%02x", result[i]];
        }
        return hashed;
      }
    
  3. Obsługuj odpowiedź Apple w swojej implementacji ASAuthorizationControllerDelegate`. Jeśli logowanie się powiodło, użyj tokena identyfikatora z odpowiedzi Apple z niezaszyfrowanym numerem jednorazowym, aby uwierzytelnić się w Firebase:

      - (void)authorizationController:(ASAuthorizationController *)controller
         didCompleteWithAuthorization:(ASAuthorization *)authorization API_AVAILABLE(ios(13.0)) {
        if ([authorization.credential isKindOfClass:[ASAuthorizationAppleIDCredential class]]) {
          ASAuthorizationAppleIDCredential *appleIDCredential = authorization.credential;
          NSString *rawNonce = self.currentNonce;
          NSAssert(rawNonce != nil, @"Invalid state: A login callback was received, but no login request was sent.");
    
          if (appleIDCredential.identityToken == nil) {
            NSLog(@"Unable to fetch identity token.");
            return;
          }
    
          NSString *idToken = [[NSString alloc] initWithData:appleIDCredential.identityToken
                                                    encoding:NSUTF8StringEncoding];
          if (idToken == nil) {
            NSLog(@"Unable to serialize id token from data: %@", appleIDCredential.identityToken);
          }
        }
    
  4. Skorzystaj z otrzymanego ciągu tokena i oryginalnej wartości jednorazowej, aby utworzyć dane logowania Firebase i zalogować się do Firebase.

    firebase::auth::OAuthProvider::GetCredential(
            /*provider_id=*/"apple.com", token, nonce,
            /*access_token=*/nullptr);
    
    firebase::Future<firebase::auth::User*> result =
        auth->SignInWithCredential(credential);
    
  5. Ten sam wzorzec może być używany z Reauthenticate którego można użyć do pobrania nowych poświadczeń dla poufnych operacji, które wymagają niedawnego logowania.

    firebase::Future<firebase::auth::SignInResult> result =
        user->Reauthenticate(credential);
    
  6. Tego samego wzorca można użyć do połączenia konta z funkcją Apple Sign In. Możesz jednak napotkać błąd, gdy istniejące konto Firebase zostało już połączone z kontem Apple, z którym próbujesz się połączyć. W takim przypadku przyszłość zwróci stan kAuthErrorCredentialAlreadyInUse a obiekt UserInfo obiektu SignInResult może zawierać poprawne updated_credential . Tego poświadczenia można użyć do zalogowania się na konto połączone z Apple za pośrednictwem SignInWithCredential bez konieczności generowania kolejnego tokenu Apple Sign In i nonce.

    Należy pamiętać, że aby ta operacja zawierała poświadczenie, należy użyć LinkAndRetrieveDataWithCredential ponieważ updated_credential jest członkiem obiektu SignInResult.UserInfo .

    firebase::Future<firebase::auth::SignInResult> link_result =
        auth->current_user()->LinkAndRetrieveDataWithCredential(credential);
    
    // To keep example simple, wait on the current thread until call completes.
    while (link_result.status() == firebase::kFutureStatusPending) {
      Wait(100);
    }
    
    // Determine the result of the link attempt
    if (link_result.error() == firebase::auth::kAuthErrorNone) {
      // user linked correctly.
    } else if (link_result.error() ==
                   firebase::auth::kAuthErrorCredentialAlreadyInUse &&
               link_result.result()->info.updated_credential.is_valid()) {
      // Sign In with the new credential
      firebase::Future<firebase::auth::User*> result = auth->SignInWithCredential(
          link_result.result()->info.updated_credential);
    } else {
      // Another link error occurred.
    }
    

W systemie Android

W systemie Android uwierzytelniaj użytkowników w Firebase, integrując internetowe ogólne logowanie OAuth z aplikacją przy użyciu pakietu Firebase SDK, aby przeprowadzić proces logowania od początku do końca.

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

  1. Utwórz wystąpienie FederatedOAuthProviderData skonfigurowane z identyfikatorem dostawcy odpowiednim dla Apple.

    firebase::auth::FederatedOAuthProviderData provider_data("apple.com");
    
  2. Opcjonalnie: określ dodatkowe zakresy OAuth 2.0 poza domyślne, których chcesz zażądać od dostawcy uwierzytelniania.

    provider_data.scopes.push_back("email");
    provider_data.scopes.push_back("name");
    
  3. Opcjonalnie: jeśli chcesz wyświetlić ekran logowania Apple w języku innym niż angielski, ustaw parametr locale . Zobacz dokumentację Logowanie za pomocą Apple, aby poznać obsługiwane języki.

    // Localize to French.
    provider_data.custom_parameters["language"] = "fr";
    ```
    
  4. Po skonfigurowaniu danych dostawcy użyj ich do utworzenia FederatedOAuthProvider.

    // Construct a FederatedOAuthProvider for use in Auth methods.
    firebase::auth::FederatedOAuthProvider provider(provider_data);
    
  5. Uwierzytelnij się w Firebase przy użyciu obiektu dostawcy uwierzytelniania. Pamiętaj, że w przeciwieństwie do innych operacji FirebaseAuth przejmie to kontrolę nad interfejsem użytkownika, wyświetlając widok sieciowy, w którym użytkownik może wprowadzić swoje poświadczenia.

    Aby rozpocząć przepływ logowania, wywołaj signInWithProvider :

    firebase::Future<firebase::auth::SignInResult> result =
      auth->SignInWithProvider(provider_data);
    

    Twoja aplikacja może wtedy czekać lub zarejestrować oddzwonienie w przyszłości .

  6. Ten sam wzorzec może być używany z ReauthenticateWithProvider którego można użyć do pobrania świeżych poświadczeń dla poufnych operacji, które wymagają niedawnego logowania.

    firebase::Future<firebase::auth::SignInResult> result =
      user->ReauthenticateWithProvider(provider_data);
    

    Twoja aplikacja może wtedy czekać lub zarejestrować oddzwonienie w przyszłości .

  7. Możesz też użyć funkcji linkWithCredential() aby połączyć różnych dostawców tożsamości z istniejącymi kontami.

    Pamiętaj, że Apple wymaga uzyskania wyraźnej zgody od użytkowników przed połączeniem ich kont Apple z innymi danymi.

    Na przykład, aby połączyć konto na Facebooku z bieżącym kontem Firebase, użyj tokena dostępu, który otrzymałeś podczas logowania użytkownika na Facebooku:

    // Initialize a Facebook credential with a Facebook access token.
    AuthCredential credential =
        firebase::auth::FacebookAuthProvider.getCredential(token);
    
    // Assuming the current user is an Apple user linking a Facebook provider.
    firebase::Future<firebase::auth::SignInResult> result =
        auth.getCurrentUser().linkWithCredential(credential);
    

Zaloguj się za pomocą Apple Notes

W przeciwieństwie do innych dostawców obsługiwanych przez Firebase Auth, Apple nie udostępnia adresu URL zdjęcia.

Ponadto, gdy użytkownik zdecyduje się nie udostępniać swojego adresu e-mail aplikacji, Apple zapewnia mu unikatowy adres e-mail (w postaci xyz@privaterelay.appleid.com ), który udostępnia Twojej aplikacji. Jeśli skonfigurowałeś prywatną usługę przekazywania poczty e-mail, Apple przekazuje wiadomości e-mail wysłane na anonimowy adres na rzeczywisty adres e-mail użytkownika.

Apple udostępnia aplikacjom informacje o użytkowniku, takie jak nazwa wyświetlana, tylko przy pierwszym logowaniu użytkownika. Zwykle Firebase przechowuje nazwę wyświetlaną przy pierwszym getCurrentUser().getDisplayName() użytkownika w Apple, którą można uzyskać za pomocą funkcji getCurrentUser().getDisplayName() . Jeśli jednak wcześniej używałeś Apple do logowania użytkownika do aplikacji bez korzystania z Firebase, Apple nie udostępni Firebase wyświetlanej nazwy użytkownika.

Następne kroki

Gdy użytkownik loguje się po raz pierwszy, tworzone jest nowe konto użytkownika i jest ono łączone z poświadczeniami - czyli nazwą użytkownika i hasłem, numerem telefonu lub informacjami dostawcy uwierzytelniania - zalogowanym użytkownikiem. To nowe konto jest przechowywane jako część projektu Firebase i może służyć do identyfikacji użytkownika we wszystkich aplikacjach w Twoim projekcie, niezależnie od tego, w jaki sposób się on loguje.

W swoich aplikacjach możesz uzyskać podstawowe informacje o profilu użytkownika z obiektu firebase :: auth :: user. Zobacz Zarządzanie użytkownikami .

W Firebase Realtime Database i Cloud Storage Rules możesz uzyskać unikalny identyfikator zalogowanego użytkownika ze zmiennej auth i użyć go do kontrolowania, do jakich danych użytkownik ma dostęp.