Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

कस्टम ऑथेंटिकेशन सिस्टम और C++ का इस्तेमाल करके, Firebase से पुष्टि करें

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

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

अपने C++ प्रोजेक्ट में Firebase जोड़ें.
अपने प्रोजेक्ट की सर्वर कुंजियां पाएं:
1. Firebase कंसोल में, सेटिंग सेटिंग > सेवा खाते टैब पर जाएं.
2. Firebase Admin SDK सेक्शन में सबसे नीचे, नई निजी कुंजी जनरेट करें पर क्लिक करें.
3. सेवा खाते की नई सार्वजनिक/निजी कुंजी की जोड़ी, आपके कंप्यूटर पर अपने-आप सेव हो जाती है. इस फ़ाइल को, पुष्टि करने वाले अपने सर्वर पर कॉपी करें.

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

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

Auth और ऐप्लिकेशन की हेडर फ़ाइलें जोड़ें:
```
#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);
```

पुष्टि करने वाले अपने सर्वर से मिले टोकन के साथ, Auth::SignInWithCustomToken को कॉल करें.

जब उपयोगकर्ता आपके ऐप्लिकेशन में साइन इन करते हैं, तो उनके साइन-इन क्रेडेंशियल (उदाहरण के लिए, उनका उपयोगकर्ता नाम और पासवर्ड) पुष्टि करने वाले अपने सर्वर को भेजें. आपका सर्वर, क्रेडेंशियल की जांच करता है. अगर वे मान्य होते हैं, तो वह एक कस्टम टोकन दिखाता है.
पुष्टि करने वाले अपने सर्वर से कस्टम टोकन मिलने के बाद, उपयोगकर्ता को साइन इन करने के लिए, उसे Auth::SignInWithCustomToken को पास करें:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithCustomToken(custom_token);
```
अगर आपके प्रोग्राम में अपडेट लूप है, जो नियमित तौर पर चलता है (मान लें कि हर सेकंड में 30 या 60 बार), तो हर अपडेट के बाद नतीजे देखे जा सकते हैं: Auth::SignInWithCustomTokenLastResult
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithCustomTokenLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for `%s`\n",
           auth_result.user.display_name().c_str());
  } else {
    printf("Sign in failed with error '%s'\n", result.error_message());
  }
}
```
इसके अलावा, अगर आपका प्रोग्राम इवेंट पर आधारित है, तो Future पर कॉलबैक रजिस्टर करना बेहतर हो सकता है.

अगले चरण

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

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

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string name = user.display_name();
  std::string email = user.email();
  std::string photo_url = user.photo_url();
  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

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

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

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

auth->SignOut();