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

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

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

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

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

Auth क्लास, सभी एपीआई कॉल के लिए गेटवे है.
  1. Auth और App हेडर फ़ाइलें जोड़ें: 
    #include <cassert>
#include <cstdint>

#include "firebase/app.h"
#include "firebase/auth.h"
  2. अपने इनिशियलाइज़ेशन कोड में, 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__)
  3. अपने firebase::App के लिए firebase::auth::Auth क्लास पाएं. App और Auth के बीच एक-से-एक मैपिंग होती है. 
    firebase::auth::Auth* auth = firebase::auth::Auth::GetAuth(app);

पासवर्ड वाला खाता बनाना

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

  1. जब कोई नया उपयोगकर्ता, आपके ऐप्लिकेशन के साइन-अप फ़ॉर्म का इस्तेमाल करके साइन अप करता है, तो खाते की पुष्टि करने के लिए, वे सभी नए चरण पूरे करें जिनकी आपके ऐप्लिकेशन को ज़रूरत है. जैसे, यह पुष्टि करना कि नए खाते का पासवर्ड सही तरीके से टाइप किया गया है और वह पासवर्ड से जुड़ी आपकी ज़रूरी शर्तों को पूरा करता है.
  2. नए उपयोगकर्ता का ईमेल पता और पासवर्ड Auth::CreateUserWithEmailAndPassword को पास करके, नया खाता बनाएं: 
    firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);
  3. अगर आपके प्रोग्राम में अपडेट लूप है, जो नियमित तौर पर चलता है (जैसे, हर सेकंड में 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());
  }
}
     इसके अलावा, अगर आपका प्रोग्राम इवेंट पर आधारित है, तो Future पर कॉलबैक रजिस्टर करें.

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

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

  1. जब कोई उपयोगकर्ता आपके ऐप्लिकेशन में साइन इन करता है, तो उपयोगकर्ता का ईमेल पता और पासवर्ड firebase::auth::Auth::SignInWithEmailAndPassword को पास करें: 
    firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);
  2. अगर आपके प्रोग्राम में अपडेट लूप है, जो नियमित तौर पर चलता है (जैसे, हर सेकंड में 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());
  }
}
     इसके अलावा, अगर आपका प्रोग्राम इवेंट पर आधारित है, तो आपको Future पर कॉलबैक रजिस्टर करना पड़ सकता है.

Future पर कॉलबैक रजिस्टर करना

कुछ प्रोग्राम में ऐसे Update फ़ंक्शन होते हैं जिन्हें हर सेकंड में 30 या 60 बार कॉल किया जाता है. उदाहरण के लिए, कई गेम इस मॉडल को फ़ॉलो करते हैं. ये प्रोग्राम, एसिंक्रोनस कॉल को पोल करने के लिए LastResult फ़ंक्शन को कॉल कर सकते हैं. हालांकि, अगर आपका प्रोग्राम इवेंट पर आधारित है, तो आपको कॉलबैक फ़ंक्शन रजिस्टर करने चाहिए. Future पूरा होने पर, कॉलबैक फ़ंक्शन को कॉल किया जाता है. 
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);
}
 अगर आपको पसंद है, तो कॉलबैक फ़ंक्शन को लैम्ब्डा के तौर पर भी इस्तेमाल किया जा सकता है. 
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 कंसोल में सुरक्षा > पुष्टि > सेटिंग टैब में जाकर, पासवर्ड से जुड़ी नीति सेक्शन खोलें:

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

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

  • छोटा अक्षर होना ज़रूरी है

  • कैपिटल लेटर ज़रूरी है

  • संख्या वाला वर्ण डालना ज़रूरी है

  • बिना अक्षर और अंक वाला वर्ण ज़रूरी है

    बिना अक्षर और अंक वाले वर्ण की ज़रूरी शर्तें पूरी करने वाले वर्ण ये हैं: ^ $ * . [ ] { } ( ) ? " ! @ # % & / \ , > < ' : ; | _ ~

  • पासवर्ड की कम से कम लंबाई (6 से 30 वर्णों तक; डिफ़ॉल्ट रूप से 6)

  • पासवर्ड की ज़्यादा से ज़्यादा लंबाई (ज़्यादा से ज़्यादा 4,096 वर्ण)

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

  • ज़रूरी है: जब तक उपयोगकर्ता आपकी नीति के मुताबिक पासवर्ड अपडेट नहीं करता, तब तक साइन अप नहीं किया जा सकता.

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

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

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

सुझाया गया: ईमेल पते की गिनती करके जानकारी इकट्ठा करने से रोकने की सुविधा चालू करें

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

इस जोखिम को कम करने के लिए, हमारा सुझाव है कि आप यह पक्का करें कि आपके प्रोजेक्ट के लिए, ईमेल पते की गिनती को सुरक्षित रखने की सुविधा चालू हो. इस सेटिंग को Firebase कंसोल में जाकर देखा जा सकता है: सुरक्षा > पुष्टि > सेटिंग टैब पर जाएं. इसके बाद, उपयोगकर्ता की कार्रवाइयां पर क्लिक करें.

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

अगले चरण

जब कोई उपयोगकर्ता पहली बार साइन इन करता है, तो एक नया उपयोगकर्ता खाता बनता है. यह खाता, उस क्रेडेंशियल से लिंक होता है जिससे उपयोगकर्ता ने साइन इन किया है. जैसे, उपयोगकर्ता का नाम और पासवर्ड, फ़ोन नंबर या पुष्टि करने वाली कंपनी की जानकारी. यह नया खाता, आपके 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 में सुरक्षा के नियमों का इस्तेमाल करके, ये काम किए जा सकते हैं: साइन इन किए हुए उपयोगकर्ता का यूनीक User-ID, auth वैरिएबल से पाएं, और इसका इस्तेमाल करके यह कंट्रोल करें कि कोई उपयोगकर्ता किस डेटा को ऐक्सेस कर सकता है.

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

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

auth->SignOut();