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

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

अपने उपयोगकर्ताओं को 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 के सदस्य कॉन्फ़िगर कर सकते हैं.

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

Apple की डेवलपर साइट के Certificates, Identifiers & Profiles पेज पर जाकर, अपने ऐप्लिकेशन के लिए 'Apple से साइन इन करें' सुविधा चालू करें.
अपनी वेबसाइट को अपने ऐप्लिकेशन से जोड़ें. इसके लिए, वेब के लिए 'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर करना लेख के पहले सेक्शन में दिए गए निर्देशों का पालन करें. जब कहा जाए, तब इस यूआरएल को रिटर्न यूआरएल के तौर पर रजिस्टर करें:
```
https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler
```
आपको Firebase कंसोल सेटिंग पेज पर अपना Firebase प्रोजेक्ट आईडी मिल सकता है. इसके बाद, अपने नए सेवा आईडी को नोट कर लें. इसकी ज़रूरत आपको अगले सेक्शन में पड़ेगी.
'Apple से साइन इन करें' सुविधा के लिए निजी कुंजी बनाएं. आपको अगले सेक्शन में, अपनी नई निजी कुंजी और कुंजी आईडी की ज़रूरत होगी.
अगर Firebase Authentication की ऐसी किसी सुविधा का इस्तेमाल किया जाता है जो लोगों को ईमेल भेजती है, तो Apple की निजी ईमेल रिले सेवा को कॉन्फ़िगर करें और noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com को रजिस्टर करें. इनमें ईमेल लिंक से साइन इन करने की सुविधा, ईमेल पते की पुष्टि करने की सुविधा, खाता बदलने की सुविधा रद्द करने की सुविधा वगैरह शामिल हैं. इसके अलावा, अगर आपको ईमेल भेजने के लिए अपने हिसाब से बनाए गए ईमेल टेंप्लेट के डोमेन का इस्तेमाल करना है, तो उसे रजिस्टर करें. इससे Apple, Firebase Authentication से भेजे गए ईमेल को Apple के ऐसे ईमेल पतों पर रिले कर पाएगा जिनकी पहचान ज़ाहिर नहीं की गई है.

अपने Apple प्रोजेक्ट में Firebase जोड़ें. Firebase कंसोल में अपना ऐप्लिकेशन सेट अप करते समय, अपने ऐप्लिकेशन के बंडल आईडी को रजिस्टर करना न भूलें.
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 के लाइसेंस समझौते को पढ़ें.

Apple से साइन इन करना और Firebase से पुष्टि करना

Apple खाते से पुष्टि करने के लिए, सबसे पहले Apple के AuthenticationServices फ़्रेमवर्क का इस्तेमाल करके, उपयोगकर्ता को उसके Apple खाते में साइन इन करें. इसके बाद, Apple से मिले जवाब में मौजूद आईडी टोकन का इस्तेमाल करके, Firebase AuthCredential ऑब्जेक्ट बनाएं:

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

SecRandomCopyBytes(_:_:_) की मदद से, क्रिप्टोग्राफ़िक रूप से सुरक्षित नॉनस जनरेट किया जा सकता है. इसका उदाहरण यहां दिया गया है:

Swift

private func randomNonceString(length: Int = 32) -> String {
  precondition(length > 0)
  var randomBytes = [UInt8](repeating: 0, count: length)
  let errorCode = SecRandomCopyBytes(kSecRandomDefault, randomBytes.count, &randomBytes)
  if errorCode != errSecSuccess {
    fatalError(
      "Unable to generate nonce. SecRandomCopyBytes failed with OSStatus \(errorCode)"
    )
  }

  let charset: [Character] =
    Array("0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._")

  let nonce = randomBytes.map { byte in
    // Pick a random character from the set, wrapping around if needed.
    charset[Int(byte) % charset.count]
  }

  return String(nonce)
}

Objective-C

// Adapted from https://auth0.com/docs/api-auth/tutorials/nonce#generate-a-cryptographically-random-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--;
      }
    }
  }

  return [result copy];
}

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

Swift

@available(iOS 13, *)
private func sha256(_ input: String) -> String {
  let inputData = Data(input.utf8)
  let hashedData = SHA256.hash(data: inputData)
  let hashString = hashedData.compactMap {
    String(format: "%02x", $0)
  }.joined()

  return hashString
}

Objective-C

- (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 के साइन-इन फ़्लो को शुरू करें. साथ ही, अपने अनुरोध में नॉनस का SHA256 हैश और डेलिगेट क्लास शामिल करें. यह डेलिगेट क्लास, Apple के जवाब को हैंडल करेगा. इसके बारे में अगले चरण में बताया गया है:

Swift

import CryptoKit

// Unhashed nonce.
fileprivate var currentNonce: String?

@available(iOS 13, *)
func startSignInWithAppleFlow() {
  let nonce = randomNonceString()
  currentNonce = nonce
  let appleIDProvider = ASAuthorizationAppleIDProvider()
  let request = appleIDProvider.createRequest()
  request.requestedScopes = [.fullName, .email]
  request.nonce = sha256(nonce)

  let authorizationController = ASAuthorizationController(authorizationRequests: [request])
  authorizationController.delegate = self
  authorizationController.presentationContextProvider = self
  authorizationController.performRequests()
}

Objective-C

@import CommonCrypto;

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

ASAuthorizationControllerDelegate को लागू करते समय, Apple के जवाब को मैनेज करें. अगर साइन-इन हो जाता है, तो Firebase से पुष्टि करने के लिए, Apple से मिले जवाब में मौजूद आईडी टोकन का इस्तेमाल करें. इसके लिए, बिना हैश किए गए नॉन्स का इस्तेमाल करें:

Swift

@available(iOS 13.0, *)
extension MainViewController: ASAuthorizationControllerDelegate {

  func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {
    if let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential {
      guard let nonce = currentNonce else {
        fatalError("Invalid state: A login callback was received, but no login request was sent.")
      }
      guard let appleIDToken = appleIDCredential.identityToken else {
        print("Unable to fetch identity token")
        return
      }
      guard let idTokenString = String(data: appleIDToken, encoding: .utf8) else {
        print("Unable to serialize token string from data: \(appleIDToken.debugDescription)")
        return
      }
      // Initialize a Firebase credential, including the user's full name.
      let credential = OAuthProvider.appleCredential(withIDToken: idTokenString,
                                                        rawNonce: nonce,
                                                        fullName: appleIDCredential.fullName)
      // Sign in with Firebase.
      Auth.auth().signIn(with: credential) { (authResult, error) in
        if error {
          // Error. If error.code == .MissingOrInvalidNonce, make sure
          // you're sending the SHA256-hashed nonce as a hex string with
          // your request to Apple.
          print(error.localizedDescription)
          return
        }
        // User is signed in to Firebase with Apple.
        // ...
      }
    }
  }

  func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: Error) {
    // Handle error.
    print("Sign in with Apple errored: \(error)")
  }

}

Objective-C

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

    // Initialize a Firebase credential, including the user's full name.
    FIROAuthCredential *credential = [FIROAuthProvider appleCredentialWithIDToken:IDToken
                                                                         rawNonce:self.appleRawNonce
                                                                         fullName:appleIDCredential.fullName];

    // Sign in with Firebase.
    [[FIRAuth auth] signInWithCredential:credential
                              completion:^(FIRAuthDataResult * _Nullable authResult,
                                           NSError * _Nullable error) {
      if (error != nil) {
        // Error. If error.code == FIRAuthErrorCodeMissingOrInvalidNonce,
        // make sure you're sending the SHA256-hashed nonce as a hex string
        // with your request to Apple.
        return;
      }
      // Sign-in succeeded!
    }];
  }
}

- (void)authorizationController:(ASAuthorizationController *)controller
           didCompleteWithError:(NSError *)error API_AVAILABLE(ios(13.0)) {
  NSLog(@"Sign in with Apple errored: %@", error);
}

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

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

अहम जानकारी: Apple, उपयोगकर्ता की जानकारी सिर्फ़ पहली बार ऐप्लिकेशन में साइन इन करने पर शेयर करता है. जैसे, डिसप्ले नेम. OAuthProvider.appleCredential(withIDToken:rawNonce:fullName:) का इस्तेमाल करें, ताकि यह पक्का किया जा सके कि जब कोई उपयोगकर्ता पहली बार Apple से साइन इन करे, तो Firebase उसका डिसप्ले नेम सेव कर ले. बाद में, Auth.auth().currentUser.displayName की मदद से उपयोगकर्ता का पूरा नाम वापस पाया जा सकता है. हालांकि, अगर आपने पहले Firebase का इस्तेमाल किए बिना, Apple का इस्तेमाल करके किसी उपयोगकर्ता को ऐप्लिकेशन में साइन इन कराया था, तो Apple, Firebase को उपयोगकर्ता का डिसप्ले नेम नहीं देगा.

फिर से पुष्टि करना और खाता लिंक करना

इसी पैटर्न का इस्तेमाल reauthenticateWithCredential() के साथ किया जा सकता है. इसका इस्तेमाल, संवेदनशील कार्रवाइयों के लिए नया क्रेडेंशियल पाने के लिए किया जा सकता है. इन कार्रवाइयों के लिए, हाल ही में साइन इन करना ज़रूरी होता है:

Swift

// Initialize a fresh Apple credential with Firebase.
let credential = OAuthProvider.credential(
  withProviderID: "apple.com",
  IDToken: appleIdToken,
  rawNonce: rawNonce
)
// Reauthenticate current Apple user with fresh Apple credential.
Auth.auth().currentUser.reauthenticate(with: credential) { (authResult, error) in
  guard error != nil else { return }
  // Apple user successfully re-authenticated.
  // ...
}

Objective-C

FIRAuthCredential *credential = [FIROAuthProvider credentialWithProviderID:@"apple.com",
                                                                   IDToken:appleIdToken,
                                                                  rawNonce:rawNonce];
[[FIRAuth auth].currentUser
    reauthenticateWithCredential:credential
                      completion:^(FIRAuthDataResult * _Nullable authResult,
                                   NSError * _Nullable error) {
  if (error) {
    // Handle error.
  }
  // Apple user successfully re-authenticated.
  // ...
}];

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

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

'Apple से साइन इन करें' सुविधा का इस्तेमाल करके, किसी मौजूदा खाते से लिंक करने के लिए, पुष्टि करने वाले क्रेडेंशियल का फिर से इस्तेमाल नहीं किया जा सकेगा. अगर आपको 'Apple से साइन इन करें' सुविधा के क्रेडेंशियल को किसी दूसरे खाते से लिंक करना है, तो आपको सबसे पहले 'Apple से साइन इन करें' सुविधा के पुराने क्रेडेंशियल का इस्तेमाल करके, खातों को लिंक करने की कोशिश करनी होगी. इसके बाद, गड़बड़ी की जांच करके नया क्रेडेंशियल ढूंढें. नया क्रेडेंशियल, गड़बड़ी की userInfo डिक्शनरी में मौजूद होगा. इसे AuthErrorUserInfoUpdatedCredentialKey कुंजी के ज़रिए ऐक्सेस किया जा सकता है.

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

Swift

// Initialize a Facebook credential with Firebase.
let credential = FacebookAuthProvider.credential(
  withAccessToken: AccessToken.current!.tokenString
)
// Assuming the current user is an Apple user linking a Facebook provider.
Auth.auth().currentUser.link(with: credential) { (authResult, error) in
  // Facebook credential is linked to the current Apple user.
  // The user can now sign in with Facebook or Apple to the same Firebase
  // account.
  // ...
}

Objective-C

// Initialize a Facebook credential with Firebase.
FacebookAuthCredential *credential = [FIRFacebookAuthProvider credentialWithAccessToken:accessToken];
// Assuming the current user is an Apple user linking a Facebook provider.
[FIRAuth.auth linkWithCredential:credential completion:^(FIRAuthDataResult * _Nullable authResult, NSError * _Nullable error) {
  // Facebook credential is linked to the current Apple user.
  // The user can now sign in with Facebook or Apple to the same Firebase
  // account.
  // ...
}];

टोकन रद्द करना

Apple का कहना है कि जिन ऐप्लिकेशन में खाता बनाने की सुविधा होती है उन्हें उपयोगकर्ताओं को ऐप्लिकेशन के अंदर ही खाता मिटाने की सुविधा देनी चाहिए. इस बारे में App Store की समीक्षा से जुड़े दिशा-निर्देशों में बताया गया है

इस ज़रूरी शर्त को पूरा करने के लिए, यह तरीका अपनाएं:

पक्का करें कि आपने 'Apple से साइन इन करें' सुविधा देने वाली कंपनी के कॉन्फ़िगरेशन में, सेवाओं का आईडी और OAuth कोड फ़्लो कॉन्फ़िगरेशन सेक्शन भर दिया हो. इसके बारे में 'Apple से साइन इन करें' सुविधा कॉन्फ़िगर करना सेक्शन में बताया गया है.

'Apple से साइन इन करें' सुविधा का इस्तेमाल करके उपयोगकर्ता खाते बनाने पर, Firebase उपयोगकर्ता टोकन सेव नहीं करता. इसलिए, टोकन रद्द करने और खाता मिटाने से पहले, आपको उपयोगकर्ता से फिर से साइन इन करने के लिए कहना होगा.

Swift

private func deleteCurrentUser() {
  do {
    let nonce = try CryptoUtils.randomNonceString()
    currentNonce = nonce
    let appleIDProvider = ASAuthorizationAppleIDProvider()
    let request = appleIDProvider.createRequest()
    request.requestedScopes = [.fullName, .email]
    request.nonce = CryptoUtils.sha256(nonce)

    let authorizationController = ASAuthorizationController(authorizationRequests: [request])
    authorizationController.delegate = self
    authorizationController.presentationContextProvider = self
    authorizationController.performRequests()
  } catch {
    // In the unlikely case that nonce generation fails, show error view.
    displayError(error)
  }
}

ASAuthorizationAppleIDCredential से ऑथराइज़ेशन कोड पाएं. इसके बाद, इसका इस्तेमाल करके Auth.auth().revokeToken(withAuthorizationCode:) को कॉल करें, ताकि उपयोगकर्ता के टोकन रद्द किए जा सकें.

Swift

func authorizationController(controller: ASAuthorizationController,
                             didCompleteWithAuthorization authorization: ASAuthorization) {
  guard let appleIDCredential = authorization.credential as? ASAuthorizationAppleIDCredential
  else {
    print("Unable to retrieve AppleIDCredential")
    return
  }

  guard let _ = currentNonce else {
    fatalError("Invalid state: A login callback was received, but no login request was sent.")
  }

  guard let appleAuthCode = appleIDCredential.authorizationCode else {
    print("Unable to fetch authorization code")
    return
  }

  guard let authCodeString = String(data: appleAuthCode, encoding: .utf8) else {
    print("Unable to serialize auth code string from data: \(appleAuthCode.debugDescription)")
    return
  }

  Task {
    do {
      try await Auth.auth().revokeToken(withAuthorizationCode: authCodeString)
      try await user?.delete()
      self.updateUI()
    } catch {
      self.displayError(error)
    }
  }
}

आखिर में, उपयोगकर्ता खाते को मिटाएं और उससे जुड़ा सारा डेटा मिटाएं

अगले चरण

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

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

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

किसी उपयोगकर्ता को साइन आउट करने के लिए, signOut: को कॉल करें.

Swift

let firebaseAuth = Auth.auth()
do {
  try firebaseAuth.signOut()
} catch let signOutError as NSError {
  print("Error signing out: %@", signOutError)
}

Objective-C

NSError *signOutError;
BOOL status = [[FIRAuth auth] signOut:&signOutError];
if (!status) {
  NSLog(@"Error signing out: %@", signOutError);
  return;
}

आपको पुष्टि से जुड़ी सभी गड़बड़ियों के लिए, गड़बड़ी मैनेज करने वाला कोड भी जोड़ना पड़ सकता है. गड़बड़ियां ठीक करना लेख पढ़ें.

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

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

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

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

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

Apple से साइन इन करना और Firebase से पुष्टि करना

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

Swift

Objective-C

फिर से पुष्टि करना और खाता लिंक करना

Swift

Objective-C

Swift

Objective-C

टोकन रद्द करना

Swift

Swift

अगले चरण

Swift

Objective-C