Apple का उपयोग करके प्रमाणित करें

आप एंड-टू-एंड OAuth 2.0 साइन-इन प्रवाह को पूरा करने के लिए Firebase SDK का उपयोग करके अपने उपयोगकर्ताओं को उनकी Apple ID का उपयोग करके Firebase से प्रमाणित करने दे सकते हैं।

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

Apple का उपयोग करने वाले उपयोगकर्ताओं को साइन इन करने के लिए, पहले Apple की डेवलपर साइट पर साइन इन विथ Apple कॉन्फ़िगर करें, फिर Apple को अपने फायरबेस प्रोजेक्ट के लिए साइन-इन प्रदाता के रूप में सक्षम करें।

Apple डेवलपर प्रोग्राम से जुड़ें

Apple के साथ साइन इन केवल Apple डेवलपर प्रोग्राम के सदस्यों द्वारा ही कॉन्फ़िगर किया जा सकता है।

Apple के साथ साइन इन कॉन्फ़िगर करें

  1. Apple की डेवलपर साइट के प्रमाणपत्र, पहचानकर्ता और प्रोफ़ाइल पृष्ठ पर अपने ऐप के लिए Apple के साथ साइन इन सक्षम करें।
  2. अपनी वेबसाइट को अपने ऐप के साथ संबद्ध करें जैसा कि वेब के लिए ऐप्पल के साथ कॉन्फिगर साइन इन के पहले खंड में बताया गया है। संकेत मिलने पर, निम्नलिखित यूआरएल को रिटर्न यूआरएल के रूप में पंजीकृत करें:
    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler
    आप फायरबेस कंसोल सेटिंग्स पेज पर अपना फायरबेस प्रोजेक्ट आईडी प्राप्त कर सकते हैं। जब आपका काम पूरा हो जाए, तो अपनी नई सेवा आईडी पर ध्यान दें, जिसकी आपको अगले भाग में आवश्यकता होगी।
  3. Apple निजी कुंजी के साथ साइन इन बनाएं । आपको अगले अनुभाग में अपनी नई निजी कुंजी और कुंजी आईडी की आवश्यकता होगी।
  4. यदि आप फ़ायरबेस प्रमाणीकरण की किसी भी सुविधा का उपयोग करते हैं जो उपयोगकर्ताओं को ईमेल भेजती है, जिसमें ईमेल लिंक साइन-इन, ईमेल पता सत्यापन, खाता परिवर्तन निरस्तीकरण और अन्य शामिल हैं, तो Apple निजी ईमेल रिले सेवा को कॉन्फ़िगर करें और noreply@ YOUR_FIREBASE_PROJECT_ID .firebaseapp.com पंजीकरण करें (या आपका अनुकूलित ईमेल टेम्प्लेट डोमेन) ताकि Apple फ़ायरबेस प्रमाणीकरण द्वारा भेजे गए ईमेल को अज्ञात Apple ईमेल पते पर रिले कर सके।

Apple को साइन-इन प्रदाता के रूप में सक्षम करें

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

Apple अज्ञात डेटा आवश्यकताओं का अनुपालन करें

साइन इन विद ऐप्पल उपयोगकर्ताओं को साइन इन करते समय अपने ईमेल पते सहित अपने डेटा को अज्ञात करने का विकल्प देता है। जो उपयोगकर्ता इस विकल्प को चुनते हैं उनके पास privaterelay.appleid.com ​​डोमेन के साथ ईमेल पते होते हैं। जब आप अपने ऐप में साइन इन विद ऐप्पल का उपयोग करते हैं, तो आपको इन अज्ञात ऐप्पल आईडी के संबंध में ऐप्पल की किसी भी लागू डेवलपर नीतियों या शर्तों का पालन करना होगा।

इसमें किसी भी सीधे पहचान वाली व्यक्तिगत जानकारी को अज्ञात ऐप्पल आईडी के साथ जोड़ने से पहले किसी भी आवश्यक उपयोगकर्ता की सहमति प्राप्त करना शामिल है। फायरबेस प्रमाणीकरण का उपयोग करते समय, इसमें निम्नलिखित क्रियाएं शामिल हो सकती हैं:

  • किसी ईमेल पते को अज्ञात Apple ID से लिंक करें या इसके विपरीत।
  • किसी फ़ोन नंबर को अज्ञात Apple ID से लिंक करें या इसके विपरीत
  • एक गैर-गुमनाम सामाजिक क्रेडेंशियल (फेसबुक, गूगल, आदि) को एक अज्ञात ऐप्पल आईडी से लिंक करें या इसके विपरीत।

उपरोक्त सूची संपूर्ण नहीं है. यह सुनिश्चित करने के लिए कि आपका ऐप Apple की आवश्यकताओं को पूरा करता है, अपने डेवलपर खाते के सदस्यता अनुभाग में Apple डेवलपर प्रोग्राम लाइसेंस अनुबंध देखें।

Apple के साथ साइन इन करें और Firebase से प्रमाणित करें

Apple खाते से प्रमाणित करने के लिए, पहले Apple के AuthenticationServices Framework का उपयोग करके उपयोगकर्ता को उनके Apple खाते में साइन इन करें, और फिर Firebase AuthCredential ऑब्जेक्ट बनाने के लिए Apple की प्रतिक्रिया से ID टोकन का उपयोग करें:

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

    आप SecRandomCopyBytes(_:_:_) के साथ एक क्रिप्टोग्राफ़िक रूप से सुरक्षित नॉन उत्पन्न कर सकते हैं, जैसा कि निम्नलिखित उदाहरण में है:

    तीव्र

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

    उद्देश्य सी

    // 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 प्रतिक्रिया में अपरिवर्तित कर देगा। फायरबेस मूल नॉन को हैश करके और ऐप्पल द्वारा पारित मूल्य से तुलना करके प्रतिक्रिया को मान्य करता है।

    तीव्र

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

    उद्देश्य सी

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

  2. Apple का साइन-इन प्रवाह प्रारंभ करें, जिसमें आपके अनुरोध में नॉन का SHA256 हैश और प्रतिनिधि वर्ग शामिल है जो Apple की प्रतिक्रिया को संभालेगा (अगला चरण देखें):

    तीव्र

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

    उद्देश्य सी

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

  3. ASAuthorizationControllerDelegate के अपने कार्यान्वयन में Apple की प्रतिक्रिया को संभालें। यदि साइन-इन सफल रहा, तो फायरबेस के साथ प्रमाणित करने के लिए अनहैश किए गए नॉन के साथ ऐप्पल की प्रतिक्रिया से आईडी टोकन का उपयोग करें:

    तीव्र

    @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)")
  }

}

    उद्देश्य सी

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

फायरबेस ऑथ द्वारा समर्थित अन्य प्रदाताओं के विपरीत, ऐप्पल एक फोटो यूआरएल प्रदान नहीं करता है।

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

पुनःप्रमाणीकरण और खाता लिंकिंग

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

तीव्र

// 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.
  // ...
}

उद्देश्य सी

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 के साथ साइन इन करने से आप किसी मौजूदा खाते से लिंक करने के लिए प्रमाणीकरण क्रेडेंशियल का पुन: उपयोग नहीं कर पाएंगे। यदि आप साइन इन विद ऐप्पल क्रेडेंशियल को किसी अन्य खाते से लिंक करना चाहते हैं, तो आपको पहले पुराने साइन इन विद ऐप्पल क्रेडेंशियल का उपयोग करके खातों को लिंक करने का प्रयास करना होगा और फिर एक नया क्रेडेंशियल ढूंढने के लिए लौटाई गई त्रुटि की जांच करनी होगी। नया क्रेडेंशियल त्रुटि के userInfo शब्दकोश में स्थित होगा और इसे AuthErrorUserInfoUpdatedCredentialKey कुंजी के माध्यम से एक्सेस किया जा सकता है।

उदाहरण के लिए, किसी फेसबुक खाते को वर्तमान फायरबेस खाते से लिंक करने के लिए, उपयोगकर्ता को फेसबुक पर साइन इन करने से प्राप्त एक्सेस टोकन का उपयोग करें:

तीव्र

// 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.
  // ...
}

उद्देश्य सी

// 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.
  // ...
}];

टोकन निरस्तीकरण

ऐप्पल के लिए आवश्यक है कि जो ऐप खाता निर्माण का समर्थन करते हैं, उन्हें उपयोगकर्ताओं को ऐप के भीतर अपना खाता हटाने की अनुमति देनी चाहिए, जैसा कि ऐप स्टोर समीक्षा दिशानिर्देशों में बताया गया है।

इस आवश्यकता को पूरा करने के लिए, निम्नलिखित चरणों को लागू करें:

  1. सुनिश्चित करें कि आपने Apple प्रदाता कॉन्फ़िगरेशन के साथ साइन इन के सेवा आईडी और OAuth कोड प्रवाह कॉन्फ़िगरेशन अनुभाग को भर दिया है, जैसा कि Apple के साथ साइन इन कॉन्फ़िगर करें अनुभाग में बताया गया है।

  2. चूँकि जब उपयोगकर्ता ऐप्पल के साथ साइन इन करते हैं तो फायरबेस उपयोगकर्ता टोकन संग्रहीत नहीं करता है, इसलिए आपको उपयोगकर्ता को उनके टोकन को रद्द करने और खाता हटाने से पहले फिर से साइन इन करने के लिए कहना होगा।

    तीव्र

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

  3. ASAuthorizationAppleIDCredential से प्राधिकरण कोड प्राप्त करें, और उपयोगकर्ता के टोकन को रद्द करने के लिए Auth.auth().revokeToken(withAuthorizationCode:) कॉल करने के लिए इसका उपयोग करें।

    तीव्र

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

  4. अंत में, उपयोगकर्ता खाता (और सभी संबद्ध डेटा) हटा दें

अगले कदम

किसी उपयोगकर्ता द्वारा पहली बार साइन इन करने के बाद, एक नया उपयोगकर्ता खाता बनाया जाता है और क्रेडेंशियल्स से लिंक किया जाता है - यानी, उपयोगकर्ता नाम और पासवर्ड, फोन नंबर, या ऑथ प्रदाता जानकारी - जिस उपयोगकर्ता के साथ साइन इन किया जाता है। यह नया खाता आपके फायरबेस प्रोजेक्ट के हिस्से के रूप में संग्रहीत है, और इसका उपयोग आपके प्रोजेक्ट के प्रत्येक ऐप में उपयोगकर्ता की पहचान करने के लिए किया जा सकता है, भले ही उपयोगकर्ता कैसे भी साइन इन करता हो।

  • अपने ऐप्स में, आप User ऑब्जेक्ट से उपयोगकर्ता की मूल प्रोफ़ाइल जानकारी प्राप्त कर सकते हैं। उपयोगकर्ता प्रबंधित करें देखें.

  • अपने फायरबेस रीयलटाइम डेटाबेस और क्लाउड स्टोरेज सुरक्षा नियमों में, आप साइन-इन किए गए उपयोगकर्ता की अद्वितीय उपयोगकर्ता आईडी को auth वेरिएबल से प्राप्त कर सकते हैं, और इसका उपयोग यह नियंत्रित करने के लिए कर सकते हैं कि उपयोगकर्ता किस डेटा तक पहुंच सकता है।

आप किसी मौजूदा उपयोगकर्ता खाते से प्रमाणीकरण प्रदाता क्रेडेंशियल्स को लिंक करके उपयोगकर्ताओं को एकाधिक प्रमाणीकरण प्रदाताओं का उपयोग करके अपने ऐप में साइन इन करने की अनुमति दे सकते हैं।

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

तीव्र

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

उद्देश्य सी

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

आप प्रमाणीकरण त्रुटियों की पूरी श्रृंखला के लिए त्रुटि प्रबंधन कोड भी जोड़ना चाह सकते हैं। त्रुटियाँ संभालें देखें।