इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

अहम जानकारी: Apple खाते से साइन इन करने के लिए, उपयोगकर्ताओं को यह करना होगा:

आपके पास Apple आईडी होना चाहिए. साथ ही, उस पर दो तरीकों से पुष्टि करने की सुविधा (2FA) चालू होनी चाहिए.
Apple डिवाइस पर iCloud में साइन इन किया गया हो.

Apple से साइन इन करने का तरीका देखें. आपको 'Sign In with Apple' के साथ इंटिग्रेशन की जांच करने के लिए, ये ज़रूरी शर्तें भी पूरी करनी होंगी.

शुरू करने से पहले

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

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

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

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

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

Apple के पहचान छिपाकर रखे गए डेटा से जुड़ी ज़रूरी शर्तों का पालन करना

Sign In with Apple की सुविधा का इस्तेमाल करने वाले लोगों के पास, साइन इन करते समय अपने डेटा को गुमनाम बनाने का विकल्प होता है. इसमें उनका ईमेल पता भी शामिल है. इस विकल्प को चुनने वाले उपयोगकर्ताओं के ईमेल पते में privaterelay.appleid.com डोमेन होता है. अपने ऐप्लिकेशन में 'Apple से साइन इन करें' सुविधा का इस्तेमाल करते समय, आपको Apple की डेवलपर नीतियों या शर्तों का पालन करना होगा. ये नीतियां या शर्तें, Apple आईडी को गुमनाम बनाए रखने से जुड़ी होती हैं.

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

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

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

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

Auth क्लास, सभी एपीआई कॉल के लिए गेटवे है.

Auth और App हेडर फ़ाइलें जोड़ें:
```
#include "firebase/app.h"
#include "firebase/auth.h"
```

अपने इनिशियलाइज़ेशन कोड में, 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__)

अपने firebase::App के लिए firebase::auth::Auth क्लास पाएं. App और Auth के बीच वन-टू-वन मैपिंग होती है.
```
firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);
```

Firebase SDK की मदद से, साइन-इन फ़्लो को मैनेज करना

Apple और Android प्लैटफ़ॉर्म पर, 'Apple से साइन इन करें' सुविधा का इस्तेमाल करने की प्रोसेस अलग-अलग होती है.

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

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

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

  - (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 से मिली वैल्यू से करता है.

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

Apple से मिले जवाब को, ASAuthorizationControllerDelegate के लागू करने के दौरान मैनेज करें. अगर साइन-इन हो जाता है, तो Apple से मिले जवाब में मौजूद आईडी टोकन का इस्तेमाल करें. साथ ही, 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);
      }
    }

नतीजे के तौर पर मिली टोकन स्ट्रिंग और ओरिजनल नॉन्स का इस्तेमाल करके, Firebase क्रेडेंशियल बनाएं और Firebase में साइन इन करें.
```
firebase::auth::OAuthProvider::GetCredential(
        /*provider_id=*/"apple.com", token, nonce,
        /*access_token=*/nullptr);

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);
```
इसी पैटर्न का इस्तेमाल Reauthenticate के साथ किया जा सकता है. इसका इस्तेमाल, संवेदनशील कार्रवाइयों के लिए नए क्रेडेंशियल वापस पाने के लिए किया जा सकता है. इन कार्रवाइयों के लिए, हाल ही में लॉग इन करना ज़रूरी होता है.
```
firebase::Future<firebase::auth::AuthResult> result =
    user->Reauthenticate(credential);
```
Apple से साइन इन करने की सुविधा का इस्तेमाल करके, किसी खाते को लिंक करने के लिए भी इसी पैटर्न का इस्तेमाल किया जा सकता है. हालांकि, अगर कोई मौजूदा Firebase खाता पहले से ही उस Apple खाते से लिंक है जिसे आपको लिंक करना है, तो आपको गड़बड़ी का मैसेज मिल सकता है. ऐसा होने पर, आने वाले समय में kAuthErrorCredentialAlreadyInUse की स्थिति दिखेगी. साथ ही, AuthResult में मान्य credential शामिल हो सकता है. इस क्रेडेंशियल का इस्तेमाल, Apple से लिंक किए गए खाते में SignInAndRetrieveDataWithCredential के ज़रिए साइन इन करने के लिए किया जा सकता है. इसके लिए, 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 का इस्तेमाल करके अपने उपयोगकर्ताओं की पुष्टि करें. इसके लिए, वेब पर आधारित सामान्य OAuth लॉगिन को Firebase SDK का इस्तेमाल करके अपने ऐप्लिकेशन में इंटिग्रेट करें, ताकि साइन-इन की प्रोसेस पूरी की जा सके.

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

Apple के लिए सही प्रोवाइडर आईडी के साथ कॉन्फ़िगर किए गए FederatedOAuthProviderData का एक इंस्टेंस बनाएं.
```
firebase::auth::FederatedOAuthProviderData provider_data("apple.com");
```
ज़रूरी नहीं: डिफ़ॉल्ट के अलावा, OAuth 2.0 के अन्य स्कोप तय करें. ये वे स्कोप होने चाहिए जिनके लिए आपको पुष्टि करने वाली कंपनी से अनुरोध करना है.
```
provider_data.scopes.push_back("email");
provider_data.scopes.push_back("name");
```
ज़रूरी नहीं: अगर आपको Apple की साइन-इन स्क्रीन को अंग्रेज़ी के अलावा किसी दूसरी भाषा में दिखाना है, तो locale पैरामीटर सेट करें. जिन भाषाओं में यह सुविधा उपलब्ध है उनके लिए, Sign In with Apple के दस्तावेज़ देखें.
```
// Localize to French.
provider_data.custom_parameters["language"] = "fr";
```
```
प्रदाता का डेटा कॉन्फ़िगर हो जाने के बाद, इसका इस्तेमाल करके FederatedOAuthProvider बनाएं.
```
// Construct a FederatedOAuthProvider for use in Auth methods.
firebase::auth::FederatedOAuthProvider provider(provider_data);
```
Auth provider ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करें. ध्यान दें कि FirebaseAuth की अन्य कार्रवाइयों के उलट, यह आपके यूज़र इंटरफ़ेस (यूआई) को कंट्रोल करेगा. इसके लिए, यह एक वेब व्यू पॉप-अप करेगा, जिसमें उपयोगकर्ता अपने क्रेडेंशियल डाल सकता है.

साइन इन करने का फ़्लो शुरू करने के लिए, signInWithProvider को कॉल करें:
```
firebase::Future<firebase::auth::AuthResult> result =
  auth->SignInWithProvider(provider_data);
```
इसके बाद, आपका ऐप्लिकेशन इंतज़ार कर सकता है या Future पर कॉलबैक रजिस्टर कर सकता है.
इसी पैटर्न का इस्तेमाल ReauthenticateWithProvider के साथ किया जा सकता है. इसका इस्तेमाल, संवेदनशील कार्रवाइयों के लिए नए क्रेडेंशियल वापस पाने के लिए किया जा सकता है. इन कार्रवाइयों के लिए, हाल ही में लॉग इन करना ज़रूरी होता है.
```
firebase::Future<firebase::auth::AuthResult> result =
  user.ReauthenticateWithProvider(provider_data);
```
इसके बाद, आपका आवेदन इंतज़ार कर सकता है या Future पर कॉलबैक रजिस्टर कर सकता है.
साथ ही, मौजूदा खातों को अलग-अलग आइडेंटिटी प्रोवाइडर से लिंक करने के लिए, 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);
```

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

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

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

अगले चरण

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

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

Firebase Realtime Database और Cloud Storage के सुरक्षा नियमों में, auth वैरिएबल से साइन इन किए गए उपयोगकर्ता का यूनीक आईडी पाया जा सकता है. इसका इस्तेमाल यह कंट्रोल करने के लिए किया जा सकता है कि कोई उपयोगकर्ता किस डेटा को ऐक्सेस कर सकता है.

शुरू करने से पहले

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

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

Apple को साइन-इन की सुविधा देने वाली कंपनी के तौर पर चालू करना