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

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

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

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

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

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

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

Apple Developer साइट पर, ये काम करें:

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

    https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler

    Firebase प्रोजेक्ट आईडी पाने के लिए, Firebase कंसोल के सेटिंग पेज पर जाएं.

    इसके बाद, अपने नए सेवा आईडी को नोट कर लें. आपको अगले सेक्शन में इसकी ज़रूरत पड़ेगी.

  2. 'Apple से साइन इन करें' की निजी पासकोड बनाएं. अगले सेक्शन में, आपको अपनी नई निजी कुंजी और कुंजी आईडी की ज़रूरत पड़ेगी.

  3. अगर Firebase Authentication की किसी ऐसी सुविधा का इस्तेमाल किया जाता है जिससे उपयोगकर्ताओं को ईमेल भेजे जाते हैं, तो Apple की निजी ईमेल रिले सेवा को कॉन्फ़िगर करें और noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com (या पसंद के मुताबिक बनाए गए ईमेल टेंप्लेट का डोमेन) रजिस्टर करें. इससे Apple, Firebase Authentication से भेजे गए ईमेल को, गुप्त रखे गए Apple ईमेल पतों पर भेज सकता है.

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

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

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

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

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

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

ऊपर दी गई सूची में प्रॉडक्ट और सेवाओं के सिर्फ़ कुछ उदाहरण दिए गए हैं. अपने डेवलपर खाते के सदस्यता सेक्शन में, Apple Developer Program के लाइसेंस एग्रीमेंट को पढ़ें. इससे आपको यह पक्का करने में मदद मिलेगी कि आपका ऐप्लिकेशन, Apple की ज़रूरी शर्तों को पूरा करता है या नहीं.

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

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

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

  1. OAuthProvider का एक इंस्टेंस बनाएं. इसके लिए, प्रोवाइडर आईडी apple.com का इस्तेमाल करें.

    Web

    import { OAuthProvider } from "firebase/auth";

const provider = new OAuthProvider('apple.com');
    auth_apple_provider_create.js

    Web

    var provider = new firebase.auth.OAuthProvider('apple.com');
    apple.js

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

    Web

    provider.addScope('email');
provider.addScope('name');
    auth_apple_provider_scopes.js

    Web

    provider.addScope('email');
provider.addScope('name');
    apple.js

    हर ईमेल पते के लिए एक खाता चालू होने पर, Firebase डिफ़ॉल्ट रूप से ईमेल और नाम के स्कोप का अनुरोध करता है. अगर इस सेटिंग को हर ईमेल पते के लिए एक से ज़्यादा खाते पर सेट किया जाता है, तो Firebase तब तक Apple से किसी स्कोप का अनुरोध नहीं करता, जब तक आपने उन्हें नहीं बताया.

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

    Web

    provider.setCustomParameters({
  // Localize the Apple authentication screen in French.
  locale: 'fr'
});
    auth_apple_provider_params.js

    Web

    provider.setCustomParameters({
  // Localize the Apple authentication screen in French.
  locale: 'fr'
});
    apple.js

  4. OAuth प्रोवाइडर ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करना. आपके पास अपने उपयोगकर्ताओं को, अपने Apple खातों से साइन इन करने के लिए कहने का विकल्प है. इसके लिए, पॉप-अप विंडो खोलें या साइन-इन पेज पर रीडायरेक्ट करें. मोबाइल डिवाइसों पर, रीडायरेक्ट करने का तरीका इस्तेमाल करना बेहतर होता है.

    • पॉप-अप विंडो से साइन इन करने के लिए, signInWithPopup() को कॉल करें:

      Web

      import { getAuth, signInWithPopup, OAuthProvider } from "firebase/auth";

const auth = getAuth();
signInWithPopup(auth, provider)
  .then((result) => {
    // The signed-in user info.
    const user = result.user;

    // Apple credential
    const credential = OAuthProvider.credentialFromResult(result);
    const accessToken = credential.accessToken;
    const idToken = credential.idToken;

    // IdP data available using getAdditionalUserInfo(result)
    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The credential that was used.
    const credential = OAuthProvider.credentialFromError(error);

    // ...
  });
      auth_apple_signin_popup.js

      Web

      firebase
  .auth()
  .signInWithPopup(provider)
  .then((result) => {
    /** @type {firebase.auth.OAuthCredential} */
    var credential = result.credential;

    // The signed-in user info.
    var user = result.user;

    // You can also get the Apple OAuth Access and ID Tokens.
    var accessToken = credential.accessToken;
    var idToken = credential.idToken;

    // IdP data available using getAdditionalUserInfo(result)
  // ...
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;

    // ...
  });
      apple.js

    • साइन इन पेज पर रीडायरेक्ट करके साइन इन करने के लिए, signInWithRedirect() को कॉल करें:

    signInWithRedirect, linkWithRedirect या reauthenticateWithRedirect का इस्तेमाल करते समय, सबसे सही तरीके अपनाएं.

    Web

    import { getAuth, signInWithRedirect } from "firebase/auth";

const auth = getAuth();
signInWithRedirect(auth, provider);
    auth_apple_signin_redirect.js

    Web

    firebase.auth().signInWithRedirect(provider);
    apple.js

    जब उपयोगकर्ता साइन इन कर लेता है और पेज पर वापस आ जाता है, तो getRedirectResult() को कॉल करके, साइन इन का नतीजा पाया जा सकता है:

    Web

    import { getAuth, getRedirectResult, OAuthProvider } from "firebase/auth";

// Result from Redirect auth flow.
const auth = getAuth();
getRedirectResult(auth)
  .then((result) => {
    const credential = OAuthProvider.credentialFromResult(result);
    if (credential) {
      // You can also get the Apple OAuth Access and ID Tokens.
      const accessToken = credential.accessToken;
      const idToken = credential.idToken;
    }
    // The signed-in user info.
    const user = result.user;
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The credential that was used.
    const credential = OAuthProvider.credentialFromError(error);

    // ...
  });
    auth_apple_signin_redirect_result.js

    Web

    // Result from Redirect auth flow.
firebase
  .auth()
  .getRedirectResult()
  .then((result) => {
    if (result.credential) {
      /** @type {firebase.auth.OAuthCredential} */
      var credential = result.credential;

      // You can get the Apple OAuth Access and ID Tokens.
      var accessToken = credential.accessToken;
      var idToken = credential.idToken;

      // IdP data available in result.additionalUserInfo.profile.
      // ...
    }
    // The signed-in user info.
    var user = result.user;
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;

    // ...
  });
    apple.js

    यहां गड़बड़ियों का पता लगाया जा सकता है और उन्हें ठीक किया जा सकता है. गड़बड़ी के कोड की सूची के लिए, एपीआई का रेफ़रंस देखें.

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

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

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

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

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

Web

import { getAuth, reauthenticateWithPopup, OAuthProvider } from "firebase/auth";

// Result from Redirect auth flow.
const auth = getAuth();
const provider = new OAuthProvider('apple.com');

reauthenticateWithPopup(auth.currentUser, provider)
  .then((result) => {
    // User is re-authenticated with fresh tokens minted and can perform
    // sensitive operations like account deletion, or updating their email
    // address or password.

    // The signed-in user info.
    const user = result.user;

    // You can also get the Apple OAuth Access and ID Tokens.
    const credential = OAuthProvider.credentialFromResult(result);
    const accessToken = credential.accessToken;
    const idToken = credential.idToken;

    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The credential that was used.
    const credential = OAuthProvider.credentialFromError(error);

    // ...
  });
auth_apple_reauthenticate_popup.js

Web

const provider = new firebase.auth.OAuthProvider('apple.com');

firebase
  .auth()
  .currentUser
  .reauthenticateWithPopup(provider)
  .then((result) => {
    // User is re-authenticated with fresh tokens minted and can perform
    // sensitive operations like account deletion, or updating their email
    // address or password.
    /** @type {firebase.auth.OAuthCredential} */
    var credential = result.credential;

    // The signed-in user info.
    var user = result.user;
     // You can also get the Apple OAuth Access and ID Tokens.
    var accessToken = credential.accessToken;
    var idToken = credential.idToken;

    // IdP data available in result.additionalUserInfo.profile.
      // ...
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;

    // ...
  });
apple.js

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

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

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

Web

import { getAuth, linkWithPopup, FacebookAuthProvider } from "firebase/auth";

const auth = getAuth();
const provider = new FacebookAuthProvider();
provider.addScope('user_birthday');

// Assuming the current user is an Apple user linking a Facebook provider.
linkWithPopup(auth.currentUser, provider)
    .then((result) => {
      // Facebook credential is linked to the current Apple user.
      // ...

      // The user can now sign in to the same account
      // with either Apple or Facebook.
    })
    .catch((error) => {
      // Handle error.
    });
auth_apple_link_facebook.js

Web

const provider = new firebase.auth.FacebookAuthProvider();
provider.addScope('user_birthday');

// Assuming the current user is an Apple user linking a Facebook provider.
firebase.auth().currentUser.linkWithPopup(provider)
    .then((result) => {
      // Facebook credential is linked to the current Apple user.
      // Facebook additional data available in result.additionalUserInfo.profile,

      // Additional Facebook OAuth access token can also be retrieved.
      // result.credential.accessToken

      // The user can now sign in to the same account
      // with either Apple or Facebook.
    })
    .catch((error) => {
      // Handle error.
    });
apple.js

Chrome एक्सटेंशन में Firebase की मदद से पुष्टि करना

अगर आपको Chrome एक्सटेंशन ऐप्लिकेशन बनाना है, तो ऑफ़स्क्रीन दस्तावेज़ों से जुड़ी गाइड देखें.

ध्यान दें कि आपको अब भी Apple के साथ कस्टम डोमेन की पुष्टि करनी होगी, ठीक वैसे ही जैसे डिफ़ॉल्ट firebaseapp.com डोमेन की पुष्टि की जाती है:

http://auth.custom.example.com/.well-known/apple-developer-domain-association.txt

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

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

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

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

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

    इसके बाद, OAuthCredential से Apple OAuth ऐक्सेस टोकन पाएं और इसका इस्तेमाल करके, revokeAccessToken(auth, token) को कॉल करें. इससे Apple OAuth ऐक्सेस टोकन रद्द हो जाएगा.

    const provider = new OAuthProvider('apple.com');
provider.addScope('email');
provider.addScope('name');

const auth = getAuth();
signInWithPopup(auth, provider).then(result => {
  // Get the Apple OAuth access token.
  const credential = OAuthProvider.credentialFromResult(result);
  const accessToken = credential.accessToken;

  // Revoke the Apple OAuth access token.
  revokeAccessToken(auth, accessToken)
    .then(() => {
      // Token revoked.

      // Delete the user account.
      // ...
    })
    .catch(error => {
      // An error happened.
      // ...
    });
});

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

बेहतर सुविधा: Node.js में Firebase से पुष्टि करना

Node.js ऐप्लिकेशन में Firebase से पुष्टि करने के लिए:

  1. उपयोगकर्ता को उसके Apple खाते से साइन इन कराएं और उसका Apple ID टोकन पाएं. ऐसा करने के कई तरीके हैं. उदाहरण के लिए, अगर आपके Node.js ऐप्लिकेशन में ब्राउज़र फ़्रंट एंड है, तो:

    1. अपने बैकएंड पर, कोई रैंडम स्ट्रिंग (एक "नॉन्स") जनरेट करें और उसका SHA256 हैश कैलकुलेट करें. नॉन्स एक बार इस्तेमाल होने वाली वैल्यू होती है. इसका इस्तेमाल, आपके बैकएंड और Apple के पुष्टि करने वाले सर्वर के बीच एक बार के राउंड ट्रिप की पुष्टि करने के लिए किया जाता है.

      Web

      const crypto = require("crypto");
const string_decoder = require("string_decoder");

// Generate a new random string for each sign-in
const generateNonce = (length) => {
  const decoder = new string_decoder.StringDecoder("ascii");
  const buf = Buffer.alloc(length);
  let nonce = "";
  while (nonce.length < length) {
    crypto.randomFillSync(buf);
    nonce = decoder.write(buf);
  }
  return nonce.slice(0, length);
};

const unhashedNonce = generateNonce(10);

// SHA256-hashed nonce in hex
const hashedNonceHex = crypto.createHash('sha256')
  .update(unhashedNonce).digest().toString('hex');
      auth_apple_nonce_node.js

      Web

      const crypto = require("crypto");
const string_decoder = require("string_decoder");

// Generate a new random string for each sign-in
const generateNonce = function(length) {
  const decoder = new string_decoder.StringDecoder("ascii");
  const buf = Buffer.alloc(length);
  var nonce = "";
  while (nonce.length < length) {
    crypto.randomFillSync(buf);
    nonce = decoder.write(buf);
  }
  return nonce.slice(0, length);
};

const unhashedNonce = generateNonce(10);

// SHA256-hashed nonce in hex
const hashedNonceHex = crypto.createHash('sha256')
  .update(unhashedNonce).digest().toString('hex');
      apple.js

    2. साइन इन पेज पर, 'Apple से साइन इन करें' कॉन्फ़िगरेशन में हैश किया गया नॉन्स डालें:

      <script src="https://appleid.cdn-apple.com/appleauth/static/jsapi/appleid/1/en_US/appleid.auth.js"></script>
<div id="appleid-signin" data-color="black" data-border="true" data-type="sign in"></div>
<script>
    AppleID.auth.init({
        clientId: YOUR_APPLE_CLIENT_ID,
        scope: 'name email',
        redirectURI: URL_TO_YOUR_REDIRECT_HANDLER,  // See the next step.
        state: '[STATE]',  // Optional value that Apple will send back to you
                           // so you can return users to the same context after
                           // they sign in.
        nonce: HASHED_NONCE  // The hashed nonce you generated in the previous step.
    });
</script>

    3. सर्वर-साइड पर पोस्ट किए गए ऑथराइज़ेशन रिस्पॉन्स से Apple ID टोकन पाएं:

      app.post('/redirect', (req, res) => {
  const savedState = req.cookies.__session;
  const code = req.body.code;
  const state = req.body.state;
  const appleIdToken = req.body.id_token;
  if (savedState !== state || !code) {
    res.status(403).send('403: Permission denied');
  } else {
    // Sign in with Firebase using appleIdToken. (See next step).
  }
});

    'Apple से साइन इन करें' सुविधा के लिए अपना वेबपेज कॉन्फ़िगर करना लेख भी पढ़ें.

  2. उपयोगकर्ता का Apple ID टोकन मिलने के बाद, उसका इस्तेमाल करके क्रेडेंशियल ऑब्जेक्ट बनाएं. इसके बाद, क्रेडेंशियल की मदद से उपयोगकर्ता को साइन इन कराएं:

    Web

    import { getAuth, signInWithCredential, OAuthProvider } from "firebase/auth";

const auth = getAuth();

// Build Firebase credential with the Apple ID token.
const provider = new OAuthProvider('apple.com');
const authCredential = provider.credential({
  idToken: appleIdToken,
  rawNonce: unhashedNonce,
});

// Sign in with credential form the Apple user.
signInWithCredential(auth, authCredential)
  .then((result) => {
    // User signed in.
  })
  .catch((error) => {
    // An error occurred. If error.code == 'auth/missing-or-invalid-nonce',
    // make sure you're sending the SHA256-hashed nonce as a hex string
    // with your request to Apple.
    console.log(error);
  });
    auth_apple_signin_nonce.js

    Web

    // Build Firebase credential with the Apple ID token.
const provider = new firebase.auth.OAuthProvider('apple.com');
const authCredential = provider.credential({
  idToken: appleIdToken,
  rawNonce: unhashedNonce,
});

// Sign in with credential form the Apple user.
firebase.auth().signInWithCredential(authCredential)
  .then((result) => {
    // User signed in.
  })
  .catch((error) => {
    // An error occurred. If error.code == 'auth/missing-or-invalid-nonce',
    // make sure you're sending the SHA256-hashed nonce as a hex string
    // with your request to Apple.
    console.log(error);
  });
    apple.js

अगले चरण

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

  • अपने ऐप्लिकेशन में, उपयोगकर्ता की पुष्टि की स्थिति जानने के लिए, Auth ऑब्जेक्ट पर ऑब्ज़र्वर सेट करने का सुझाव दिया जाता है. इसके बाद, User ऑब्जेक्ट से उपयोगकर्ता की प्रोफ़ाइल की बुनियादी जानकारी पाई जा सकती है. उपयोगकर्ताओं को मैनेज करें देखें.

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

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

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

Web

import { getAuth, signOut } from "firebase/auth";

const auth = getAuth();
signOut(auth).then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});
auth_sign_out.js

Web

firebase.auth().signOut().then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});
index.js