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

C++ का इस्तेमाल करके, पासवर्ड पर आधारित खातों का इस्तेमाल करके Firebase से पुष्टि करें

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

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

अपने C++ प्रोजेक्ट में Firebase जोड़ें.
अगर आपने अपने ऐप्लिकेशन को अब तक अपने Firebase प्रोजेक्ट से कनेक्ट नहीं किया है, तो Firebase console से ऐसा करें.
अपने Firebase प्रोजेक्ट के लिए, ईमेल/पासवर्ड को साइन-इन करने की सुविधा देने वाले प्लैटफ़ॉर्म के तौर पर चालू करें:
1. Firebase console में, सुरक्षा > पुष्टि करना पर जाएं.
2. साइन-इन करने का तरीका टैब में, ईमेल/पासवर्ड को साइन-इन करने की सुविधा देने वाले प्लैटफ़ॉर्म को चालू करें.
3. सेव करें पर क्लिक करें.
अहम जानकारी: अगर आपको Firebase CLI का इस्तेमाल करना है, तो पुष्टि करने की सुविधा देने वाले प्लैटफ़ॉर्म कॉन्फ़िगर करने के लिए, firebase init auth चलाएं. इसके बाद, अपने प्रोजेक्ट में बदलाव लागू करने के लिए, firebase deploy --only auth चलाएं.

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

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::CreateUserWithEmailAndPassword` में, नए उपयोगकर्ता का ईमेल पता और पासवर्ड डालकर एक नया खाता बनाएं:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
```
अगर आपके प्रोग्राम में अपडेट लूप है, जो नियमित तौर पर चलता है (मान लें कि हर सेकंड में 30 या 60 बार), तो Auth::CreateUserWithEmailAndPasswordLastResult की मदद से, हर अपडेट के बाद नतीजे देखे जा सकते हैं:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    const firebase::auth::AuthResult auth_result = *result.result();
    printf("Create user succeeded for email %s\n",
           auth_result.user.email().c_str());
  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}
```
इसके अलावा, अगर आपका प्रोग्राम इवेंट पर आधारित है, तो आपके पास फ़्यूचर पर कॉलबैक रजिस्टर करने का विकल्प होता है.

अपने प्रोजेक्ट को गलत इस्तेमाल से बचाने के लिए, Firebase, ईमेल/पासवर्ड और गुमनाम साइन-अप की संख्या को सीमित करता है. यह सीमा, आपके ऐप्लिकेशन के लिए, एक ही आईपी पते से, कम समय में लागू होती है. आप Firebase कंसोल से इस कोटे में अस्थायी बदलावों का अनुरोध कर सकते हैं और उन्हें शेड्यूल कर सकते हैं (सुरक्षा > पुष्टि करना > साइन-इन करने का तरीका टैब पर जाएं).

ईमेल पते और पासवर्ड की मदद से किसी उपयोगकर्ता को साइन इन करना

पासवर्ड की मदद से किसी उपयोगकर्ता को साइन इन करने का तरीका, नया खाता बनाने के तरीके जैसा ही होता है. अपने ऐप्लिकेशन के साइन-इन फ़ंक्शन में, यह तरीका अपनाएं:

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

किसी फ़्यूचर पर कॉलबैक रजिस्टर करना

कुछ प्रोग्राम में Update फ़ंक्शन होते हैं, जिन्हें हर सेकंड में 30 या 60 बार कॉल किया जाता है. उदाहरण के लिए, कई गेम इस मॉडल को फ़ॉलो करते हैं. ये प्रोग्राम, एसिंक्रोनस कॉल को पोल करने के लिए, LastResult फ़ंक्शन को कॉल कर सकते हैं. हालांकि, अगर आपका प्रोग्राम इवेंट पर आधारित है, तो आपके पास कॉलबैक फ़ंक्शन रजिस्टर करने का विकल्प होता है. फ़्यूचर पूरा होने पर, कॉलबैक फ़ंक्शन को कॉल किया जाता है.

void OnCreateCallback(const firebase::Future<firebase::auth::User*>& result,
                      void* user_data) {
  // The callback is called when the Future enters the `complete` state.
  assert(result.status() == firebase::kFutureStatusComplete);

  // Use `user_data` to pass-in program context, if you like.
  MyProgramContext* program_context = static_cast<MyProgramContext*>(user_data);

  // Important to handle both success and failure situations.
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());

    // Perform other actions on User, if you like.
    firebase::auth::User::UserProfile profile;
    profile.display_name = program_context->display_name;
    user->UpdateUserProfile(profile);

  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

void CreateUser(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}

अगर आपको कॉलबैक फ़ंक्शन के तौर पर lambda का इस्तेमाल करना है, तो ऐसा किया जा सकता है.

void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // The lambda has the same signature as the callback function.
  result.OnCompletion(
      [](const firebase::Future<firebase::auth::User*>& result,
         void* user_data) {
        // `user_data` is the same as &my_program_context, below.
        // Note that we can't capture this value in the [] because std::function
        // is not supported by our minimum compiler spec (which is pre C++11).
        MyProgramContext* program_context =
            static_cast<MyProgramContext*>(user_data);

        // Process create user result...
        (void)program_context;
      },
      &my_program_context);
}

सुझाव: पासवर्ड की नीति सेट करना

पासवर्ड की जटिलता की ज़रूरी शर्तें लागू करके, खाते की सुरक्षा को बेहतर बनाया जा सकता है.

अपने प्रोजेक्ट के लिए पासवर्ड की नीति कॉन्फ़िगर करने के लिए, पासवर्ड की नीति सेक्शन खोलें. यह सेक्शन सुरक्षा > पुष्टि करना > सेटिंग टैब में है. यह टैब Firebase console में है:

पुष्टि करने की सेटिंग

Firebase Authentication पासवर्ड नीतियां, पासवर्ड की इन ज़रूरी शर्तों के साथ काम करती हैं:

लोअरकेस वर्ण ज़रूरी है
अपरकेस वर्ण ज़रूरी है
संख्या वाला वर्ण ज़रूरी है
बिना अक्षर और अंक वाला वर्ण ज़रूरी है

बिना अक्षर और अंक वाले वर्ण की ज़रूरी शर्त को पूरा करने के लिए, इन वर्णों का इस्तेमाल किया जा सकता है: ^ $ * . [ ] { } ( ) ? " ! @ # % & / \ , > < ' : ; | _ ~
पासवर्ड की कम से कम लंबाई (6 से 30 वर्ण; डिफ़ॉल्ट रूप से 6)
पासवर्ड की ज़्यादा से ज़्यादा लंबाई (ज़्यादा से ज़्यादा 4,096 वर्ण)

पासवर्ड की नीति को दो मोड में लागू किया जा सकता है:

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

नए उपयोगकर्ताओं को हमेशा ऐसा पासवर्ड चुनना होता है जो आपकी नीति के मुताबिक हो.

अगर आपके पास सक्रिय उपयोगकर्ता हैं, तो हमारा सुझाव है कि साइन इन करने पर, अपग्रेड करने की सुविधा को तब तक चालू न करें, जब तक आपका इरादा उन उपयोगकर्ताओं के ऐक्सेस को ब्लॉक करने का न हो जिनके पासवर्ड आपकी नीति के मुताबिक नहीं हैं. इसके बजाय, सूचना मोड का इस्तेमाल करें. इससे उपयोगकर्ताओं को अपने मौजूदा पासवर्ड से साइन इन करने की अनुमति मिलती है. साथ ही, उन्हें यह भी बताया जाता है कि उनके पासवर्ड में किन ज़रूरी शर्तों की कमी है.

सुझाव: ईमेल की गिनती से सुरक्षा की सुविधा चालू करना

कुछ Firebase Authentication तरीकों में, ईमेल पतों को पैरामीटर के तौर पर इस्तेमाल किया जाता है. अगर ईमेल पता रजिस्टर नहीं है, तो ये तरीके खास तरह की गड़बड़ियां दिखाते हैं. ऐसा तब होता है, जब ईमेल पता रजिस्टर होना चाहिए. उदाहरण के लिए, ईमेल पते और पासवर्ड की मदद से साइन इन करते समय. इसके अलावा, अगर ईमेल पता रजिस्टर है, तो ये तरीके गड़बड़ियां दिखाते हैं. ऐसा तब होता है, जब ईमेल पते का इस्तेमाल नहीं किया जाना चाहिए. उदाहरण के लिए, किसी उपयोगकर्ता का ईमेल पता बदलते समय. इससे उपयोगकर्ताओं को खास समाधान सुझाने में मदद मिल सकती है. हालांकि, इसका गलत इस्तेमाल करके, बुरे इरादे वाले लोग आपके उपयोगकर्ताओं के रजिस्टर किए गए ईमेल पतों का पता लगा सकते हैं.

इस जोखिम को कम करने के लिए, हमारा सुझाव है कि आप ईमेल की गिनती से सुरक्षा की सुविधा चालू करें Google Cloud gcloud टूल का इस्तेमाल करके, अपने प्रोजेक्ट के लिए. ध्यान दें कि इस सुविधा को चालू करने से, Firebase Authentication's की गड़बड़ी की रिपोर्टिंग के तरीके में बदलाव होता है. इसलिए, पक्का करें कि आपका ऐप्लिकेशन ज़्यादा खास गड़बड़ियों पर निर्भर न हो.

अगले चरण

जब कोई उपयोगकर्ता पहली बार साइन इन करता है, तो एक नया उपयोगकर्ता खाता बनता है. यह खाता, उन क्रेडेंशियल से लिंक होता है जिनका इस्तेमाल करके उपयोगकर्ता ने साइन इन किया है. जैसे, उपयोगकर्ता नाम और पासवर्ड, फ़ोन नंबर या पुष्टि करने की सुविधा देने वाले प्लैटफ़ॉर्म की जानकारी. यह नया खाता, आपके 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();