C++ में Firebase से पुष्टि करने की सुविधा का इस्तेमाल करना शुरू करें

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

अपने C++ प्रोजेक्ट को Firebase से कनेक्ट करें

Firebase से पुष्टि करने की सुविधा का इस्तेमाल करने से पहले, आपको:

  • अपना C++ प्रोजेक्ट रजिस्टर करें और उसे Firebase का इस्तेमाल करने के लिए कॉन्फ़िगर करें.

    अगर आपके C++ प्रोजेक्ट में पहले से ही Firebase का इस्तेमाल हो रहा है, तो इसका मतलब है कि वह पहले से रजिस्टर है और Firebase के लिए कॉन्फ़िगर हो चुका है.

  • अपने C++ प्रोजेक्ट में Firebase C++ SDK टूल जोड़ें.

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

नए उपयोगकर्ताओं के लिए साइन अप करें

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

firebase::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPassword(email, password);

CreateUserWithEmailAndPasswordLastResult फ़्यूचर ऑब्जेक्ट पर कॉलबैक रजिस्टर करके, खाता बनाने की कार्रवाई की स्थिति देखी जा सकती है. इसके अलावा, अगर किसी गेम या ऐप्लिकेशन को समय-समय पर अपडेट होने वाले लूप में लिखा जा रहा है, तो अपडेट लूप में स्टेटस पोल करके भी खाता बनाया जा सकता है.

उदाहरण के लिए, भविष्य का इस्तेमाल करके:

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::AuthResult>& 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::Future<firebase::auth::AuthResult> result =
    auth->CreateUserWithEmailAndPasswordLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    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());
  }
}

मौजूदा उपयोगकर्ताओं को साइन इन करने की अनुमति है

एक ऐसा फ़ॉर्म बनाएं जिससे मौजूदा उपयोगकर्ता अपने ईमेल पते और पासवर्ड से साइन इन कर सकें. जब कोई उपयोगकर्ता फ़ॉर्म भर लेता है, तो SignInWithEmailAndPassword तरीके को कॉल करें:

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithEmailAndPassword(email, password);

साइन इन की कार्रवाई का नतीजा उसी तरह पाएं जिस तरह आपको साइन अप का नतीजा मिला था.

पुष्टि करने की स्थिति लिसनर सेट करें और खाते का डेटा पाएं

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

firebase::auth::AuthStateListener ऐब्स्ट्रैक्ट क्लास लागू करके, लिसनर बनाएं. उदाहरण के लिए, ऐसा लिसनर बनाने के लिए जिसे उपयोगकर्ता के सही तरीके से साइन इन करने पर उपयोगकर्ता के बारे में जानकारी मिलती है:

class MyAuthStateListener : public firebase::auth::AuthStateListener {
 public:
  void OnAuthStateChanged(firebase::auth::Auth* auth) override {
    firebase::auth::User user = auth.current_user();
    if (user.is_valid()) {
      // User is signed in
      printf("OnAuthStateChanged: signed_in %s\n", user.uid().c_str());
      const std::string displayName = user.DisplayName();
      const std::string emailAddress = user.Email();
      const std::string photoUrl = user.PhotoUrl();
    } else {
      // User is signed out
      printf("OnAuthStateChanged: signed_out\n");
    }
    // ...
  }
};

firebase::auth::Auth ऑब्जेक्ट के AddAuthStateListener तरीके का इस्तेमाल करके, लिसनर को अटैच करें:

MyAuthStateListener state_change_listener;
auth->AddAuthStateListener(&state_change_listener);

अगले चरण

पहचान देने वाली दूसरी कंपनियों और पहचान छिपाने वाले मेहमान खातों के लिए, सहायता जोड़ने का तरीका जानें: