Apple और C++ का इस्तेमाल करके पुष्टि करें

शुरू से आखिर तक OAuth 2.0 साइन-इन फ़्लो लागू करने के लिए, Firebase SDK टूल का इस्तेमाल करके अपने उपयोगकर्ताओं को उनके Apple आईडी का इस्तेमाल करके, Firebase की पुष्टि करने की अनुमति दी जा सकती है.

वेब कंटेनर इंस्टॉल करने से पहले

Apple का इस्तेमाल करके साइन इन करने के लिए, पहले Apple की डेवलपर साइट पर 'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर करें. इसके बाद, Apple को अपने Firebase प्रोजेक्ट में साइन-इन की सुविधा देने वाली कंपनी के तौर पर चालू करें.

Apple Developer Program में शामिल होना

'Apple से साइन इन करें' सुविधा को सिर्फ़ Apple Developer Program के सदस्य कॉन्फ़िगर कर सकते हैं.

'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर करें

आपके Firebase प्रोजेक्ट में, Apple साइन इन की सुविधा चालू होनी चाहिए और उसे ठीक से कॉन्फ़िगर किया जाना चाहिए. Android और Apple प्लैटफ़ॉर्म के हिसाब से कॉन्फ़िगरेशन अलग-अलग होता है. आगे बढ़ने से पहले, कृपया Apple प्लैटफ़ॉर्म के "Apple से साइन इन कॉन्फ़िगर करें" सेक्शन और/या Android गाइड का पालन करें.

साइन इन की सेवा देने वाली कंपनी के तौर पर Apple की सेवाएं चालू करें

  1. Firebase कंसोल में, पुष्टि करें सेक्शन खोलें. साइन इन करने का तरीका टैब पर, Apple प्रोवाइडर को चालू करें.
  2. Apple की साइन इन सेवा देने वाली कंपनी की सेटिंग कॉन्फ़िगर करें:
    1. अगर अपने ऐप्लिकेशन को सिर्फ़ Apple प्लैटफ़ॉर्म पर डिप्लॉय किया जा रहा है, तो सेवा आईडी, Apple का टीम आईडी, निजी पासकोड, और कुंजी आईडी वाले फ़ील्ड खाली छोड़े जा सकते हैं.

    2. Android डिवाइसों पर सहायता पाने के लिए:
      1. अपने Android प्रोजेक्ट में Firebase जोड़ें. Firebase कंसोल में अपना ऐप्लिकेशन सेट अप करते समय, अपने ऐप्लिकेशन का SHA-1 हस्ताक्षर रजिस्टर करना न भूलें.
      2. Firebase कंसोल में, पुष्टि करें सेक्शन खोलें. साइन इन करने का तरीका टैब पर, Apple प्रोवाइडर को चालू करें. पिछले सेक्शन में बनाया गया सेवा आईडी बताएं. साथ ही, OAuth कोड फ़्लो के कॉन्फ़िगरेशन सेक्शन में, अपना Apple Team ID और पिछले सेक्शन में बनाए गए निजी पासकोड और कुंजी आईडी की जानकारी दें.

Apple की पहचान छिपाकर डेटा इस्तेमाल करने की ज़रूरी शर्तों को पूरा करता है

'Apple से साइन इन करें' सुविधा की मदद से, उपयोगकर्ताओं को यह विकल्प मिलता है कि वे साइन इन करते समय, अपने डेटा और ईमेल पते की पहचान छिपा सकते हैं. यह विकल्प चुनने वाले उपयोगकर्ताओं के ईमेल पते, privaterelay.appleid.com डोमेन वाले होते हैं. अपने ऐप्लिकेशन में 'Apple से साइन इन करें' सुविधा का इस्तेमाल करते समय, आपको पहचान छिपाने वाले इन Apple ID से जुड़ी, लागू होने वाली डेवलपर नीतियों या Apple की शर्तों का पालन करना होगा.

इसमें पहचान ज़ाहिर किए बिना पहचान ज़ाहिर करने वाली किसी भी निजी जानकारी को पहचान छिपाने वाले Apple ID से जोड़ने से पहले, उपयोगकर्ता की ज़रूरी सहमति लेना भी शामिल है. Firebase से पुष्टि करने की सुविधा का इस्तेमाल करते समय, इसमें ये कार्रवाइयां शामिल हो सकती हैं:

  • किसी ईमेल पते को पहचान छिपाने वाले Apple ID से लिंक करें. इसी तरह, पहचान छिपाने वाले Apple ID से किसी ईमेल पते को लिंक करें.
  • किसी फ़ोन नंबर को पहचान छिपाने वाले Apple ID से लिंक करें. इसी तरह, किसी फ़ोन नंबर को बिना पहचान वाले Apple ID से लिंक करें
  • बिना पहचान वाले सोशल क्रेडेंशियल (Facebook, Google वगैरह) को बिना पहचान वाले Apple ID से लिंक करें. इसके अलावा, पहचान छिपाने वाले सोशल क्रेडेंशियल (Facebook, Google वगैरह) को जोड़ें.

ऊपर दी गई सूची पूरी नहीं है. यह पक्का करने के लिए कि आपका ऐप्लिकेशन, Apple की ज़रूरी शर्तों को पूरा करता है, अपने डेवलपर खाते के सदस्यता सेक्शन में जाकर, Apple Developer Program के लाइसेंस का कानूनी समझौता देखें.

firebase::auth::Auth क्लास को ऐक्सेस करें

Auth क्लास, सभी एपीआई कॉल के लिए गेटवे होती है.
  1. पुष्टि करें और ऐप्लिकेशन की हेडर फ़ाइलें जोड़ें: 
    #include "firebase/app.h"
#include "firebase/auth.h"
  2. अपने शुरू करने वाले कोड में, 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::App के लिए firebase::auth::Auth क्लास पाएं. App और Auth के बीच वन-टू-वन मैपिंग है. 
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

Firebase SDK टूल की मदद से साइन-इन की प्रोसेस को मैनेज करना

Apple और Android प्लैटफ़ॉर्म पर साइन-इन करने की प्रोसेस अलग-अलग होती है.

Apple प्लैटफ़ॉर्म पर

अपने C++ कोड से शुरू किए गए Apple Sign In Objective-C SDK टूल की मदद से, Firebase की मदद से अपने उपयोगकर्ताओं की पुष्टि करें.

  1. साइन-इन करने के हर अनुरोध के लिए, एक रैंडम स्ट्रिंग जनरेट करें. इस स्ट्रिंग को "nonce" कहा जाता है. इसका इस्तेमाल यह पक्का करने के लिए किया जाएगा कि आपको जो आईडी टोकन मिला है उसे खास तौर पर, आपके ऐप्लिकेशन के पुष्टि करने के अनुरोध के जवाब में दिया गया हो. रीप्ले से होने वाले हमलों से बचने के लिए, यह तरीका ज़रूरी है.

      - (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--;
        }
      }
    }
  }

    आपको अपने साइन-इन अनुरोध के साथ, नॉन्स का SHA256 हैश भेजना होगा. Apple, रिस्पॉन्स में बिना बदलाव किए इसे पास करेगा. Firebase, रिस्पॉन्स की पुष्टि करता है. इसके लिए, वह ओरिजनल नॉन्स को हैश करके उसकी तुलना Apple से मिली वैल्यू से करता है.

  2. Apple का साइन-इन फ़्लो शुरू करें. इसमें नॉन्स के SHA256 हैश और Apple के रिस्पॉन्स को हैंडल करने वाली डेलिगेट क्लास को शामिल करें (अगला चरण देखें):

      - (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. ASAuthorizationControllerDelegate` लागू करने के दौरान, Apple का रिस्पॉन्स मैनेज करें. अगर साइन इन हो जाता है, तो Firebase से पुष्टि करने के लिए, बिना हैश किए गए नॉन्स के साथ Apple के रिस्पॉन्स से मिले आईडी टोकन का इस्तेमाल करें:

      - (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. Firebase क्रेडेंशियल बनाने और Firebase में साइन इन करने के लिए, मिलने वाली टोकन स्ट्रिंग और ओरिजनल नॉन्स का इस्तेमाल करें.

    firebase::auth::OAuthProvider::GetCredential(
        /*provider_id=*/"apple.com", token, nonce,
        /*access_token=*/nullptr);

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

  5. यही पैटर्न, Reauthenticate के साथ भी इस्तेमाल किया जा सकता है. इसका इस्तेमाल, संवेदनशील कार्रवाइयों के लिए नए क्रेडेंशियल हासिल करने के लिए किया जा सकता है, जिनमें हाल ही में लॉगिन करने की ज़रूरत होती है.

    firebase::Future<firebase::auth::AuthResult> result =
    user->Reauthenticate(credential);

  6. Apple साइन इन की मदद से किसी खाते को लिंक करने के लिए, इसी पैटर्न का इस्तेमाल किया जा सकता है. हालांकि, अगर कोई मौजूदा Firebase खाता पहले से ही उस Apple खाते से लिंक किया गया है जिसे आपको लिंक करना है, तो आपको गड़बड़ी का मैसेज मिल सकता है. ऐसा होने पर, आने वाले समय में kAuthErrorCredentialAlreadyInUse का स्टेटस दिखेगा और AuthResult में मान्य credential हो सकता है. इस क्रेडेंशियल का इस्तेमाल, SignInAndRetrieveDataWithCredential से Apple से लिंक किए गए खाते में साइन इन करने के लिए किया जा सकता है. इसके लिए, कोई दूसरा Apple साइन इन टोकन और नॉन्स जनरेट करने की ज़रूरत नहीं होती.

    firebase::Future<firebase::auth::AuthResult> link_result =
    auth->current_user().LinkWithCredential(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()
               ->additional_user_info.updated_credential.is_valid()) {
  // Sign In with the new credential
  firebase::Future<firebase::auth::AuthResult> result =
      auth->SignInAndRetrieveDataWithCredential(
          link_result.result()->additional_user_info.updated_credential);
} else {
  // Another link error occurred.
}

Android पर

Android पर, अपने उपयोगकर्ताओं को Firebase की मदद से पुष्टि करें. इसके लिए, Firebase SDK टूल का इस्तेमाल करके वेब पर आधारित सामान्य OAuth लॉगिन को अपने ऐप्लिकेशन में इंटिग्रेट करें, ताकि आखिर से आखिर तक साइन-इन किया जा सके.

Firebase SDK टूल की मदद से साइन इन फ़्लो मैनेज करने के लिए, यह तरीका अपनाएं:

  1. Apple के लिए सही प्रोवाइडर आईडी के साथ कॉन्फ़िगर किए गए FederatedOAuthProviderData का इंस्टेंस बनाएं.

    firebase::auth::FederatedOAuthProviderData provider_data("apple.com");

  2. ज़रूरी नहीं: पुष्टि करने की सेवा देने वाली कंपनी से अनुरोध करने के लिए, डिफ़ॉल्ट स्कोप के अलावा, OAuth 2.0 के अन्य स्कोप शामिल करें.

    provider_data.scopes.push_back("email");
provider_data.scopes.push_back("name");

  3. ज़रूरी नहीं: अगर आपको Apple की साइन-इन स्क्रीन को अंग्रेज़ी के अलावा किसी दूसरी भाषा में दिखाना है, तो locale पैरामीटर सेट करें. इस्तेमाल की जाने वाली भाषाओं के लिए, Apple के दस्तावेज़ों से साइन इन करें सेक्शन देखें.

    // Localize to French.
provider_data.custom_parameters["language"] = "fr";
```

  4. सेवा देने वाली कंपनी का डेटा कॉन्फ़िगर हो जाने के बाद, उसका इस्तेमाल FederatedOAuthProvider बनाने के लिए करें.

    // Construct a FederatedOAuthProvider for use in Auth methods.
firebase::auth::FederatedOAuthProvider provider(provider_data);

  5. पुष्टि करने वाले ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करें. ध्यान दें कि FirebaseAuth की दूसरी कार्रवाइयों के उलट, यह वेब व्यू को पॉप अप करके आपके यूज़र इंटरफ़ेस (यूआई) को कंट्रोल करेगा. इसमें उपयोगकर्ता अपने क्रेडेंशियल डाल सकता है.

    साइन इन फ़्लो शुरू करने के लिए, signInWithProvider को कॉल करें:

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

    इसके बाद, आपका ऐप्लिकेशन इंतज़ार कर सकता है या आने वाले समय में कॉलबैक के लिए रजिस्टर कर सकता है.

  6. यही पैटर्न, ReauthenticateWithProvider के साथ भी इस्तेमाल किया जा सकता है. इसका इस्तेमाल, संवेदनशील कार्रवाइयों के लिए नए क्रेडेंशियल हासिल करने के लिए किया जा सकता है, जिनमें हाल ही में लॉगिन करने की ज़रूरत होती है.

    firebase::Future<firebase::auth::AuthResult> result =
  user.ReauthenticateWithProvider(provider_data);

    इसके बाद, आपका ऐप्लिकेशन इंतज़ार कर सकता है या आने वाले समय में कॉलबैक रजिस्टर कर सकता है.

  7. साथ ही, अलग-अलग आइडेंटिटी प्रोवाइडर को मौजूदा खातों से लिंक करने के लिए, LinkWithCredential() का इस्तेमाल किया जा सकता है.

    ध्यान दें कि Apple के उपयोगकर्ताओं के Apple खातों को अन्य डेटा से लिंक करने से पहले, आपको उनकी सहमति लेनी होगी.

    उदाहरण के लिए, किसी Facebook खाते को मौजूदा Firebase खाते से लिंक करने के लिए, उस ऐक्सेस टोकन का इस्तेमाल करें जो आपको उपयोगकर्ता को Facebook में साइन इन करने पर मिला है:

    // 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::AuthResult> result =
    auth.current_user().LinkWithCredential(credential);

Apple Notes से साइन इन करें

Firebase पुष्टि के साथ काम करने वाली दूसरी कंपनियों के उलट, Apple कोई फ़ोटो का यूआरएल नहीं देता.

साथ ही, जब उपयोगकर्ता इस ऐप्लिकेशन के साथ अपना ईमेल शेयर नहीं करने का विकल्प चुनता है, तो Apple उस उपयोगकर्ता के लिए (xyz@privaterelay.appleid.com फ़ॉर्म का) एक यूनीक ईमेल पता उपलब्ध कराता है. इसे वह आपके ऐप्लिकेशन के साथ शेयर करता है. अगर आपने निजी ईमेल रिले सेवा को कॉन्फ़िगर किया है, तो Apple, उपयोगकर्ता की पहचान छिपाने वाले ईमेल पते पर भेजे गए ईमेल को उपयोगकर्ता के असली ईमेल पते पर फ़ॉरवर्ड कर देता है.

Apple उपयोगकर्ता की जानकारी, जैसे कि डिसप्ले नेम को उपयोगकर्ता के पहली बार साइन इन करने पर ही ऐप्लिकेशन के साथ शेयर करता है. आम तौर पर, जब कोई उपयोगकर्ता पहली बार Apple में साइन इन करता है, तब Firebase उस डिसप्ले नेम को सेव करता है. यह नाम आपको current_user().display_name() से मिल सकता है. हालांकि, अगर आपने पहले Firebase का इस्तेमाल किए बिना ऐप्लिकेशन में किसी उपयोगकर्ता को साइन इन करने के लिए Apple का इस्तेमाल किया है, तो Apple आपको उपयोगकर्ता का डिसप्ले नेम नहीं दिखाएगा.

अगले चरण

जब कोई उपयोगकर्ता पहली बार साइन इन करता है, तो एक नया उपयोगकर्ता खाता बनाया जाता है और उपयोगकर्ता के क्रेडेंशियल से लिंक किया जाता है. इन क्रेडेंशियल में उपयोगकर्ता नाम और पासवर्ड, फ़ोन नंबर या पुष्टि करने वाली सेवा की जानकारी शामिल है. यह नया खाता आपके Firebase प्रोजेक्ट के हिस्से के तौर पर सेव होता है. साथ ही, इसका इस्तेमाल आपके प्रोजेक्ट के हर ऐप्लिकेशन में उपयोगकर्ता की पहचान करने के लिए किया जा सकता है. भले ही, उपयोगकर्ता ने किसी भी तरह से साइन इन किया हो.

अपने ऐप्लिकेशन में, उपयोगकर्ता की प्रोफ़ाइल की बुनियादी जानकारी को firebase::auth::User ऑब्जेक्ट से लिया जा सकता है. उपयोगकर्ताओं को मैनेज करें देखें.

अपने Firebase रीयल टाइम डेटाबेस और Cloud Storage के सुरक्षा नियमों में, आपको ऑथराइज़ेशन वैरिएबल से साइन-इन किए हुए उपयोगकर्ता का यूनीक यूज़र आईडी मिल सकता है. साथ ही, इसका इस्तेमाल यह कंट्रोल करने के लिए किया जा सकता है कि उपयोगकर्ता कौनसा डेटा ऐक्सेस कर सकता है.