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

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

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

Firebase Authentication का इस्तेमाल करने से पहले, आपको ये काम करने होंगे:

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

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

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

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

नए उपयोगकर्ताओं को साइन अप करने की सुविधा देना

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

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

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

उदाहरण के लिए, 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::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);

साइन-इन करने की कार्रवाई का नतीजा उसी तरह पाएं जिस तरह आपने साइन-अप करने की कार्रवाई का नतीजा पाया था.

पुष्टि करने की स्थिति के लिसनर को सेट करना और खाते में मौजूद डेटा पाना

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

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);

अगले चरण

अन्य आइडेंटिटी प्रोवाइडर और पहचान ज़ाहिर किए बिना मेहमान के तौर पर इस्तेमाल किए जाने वाले खातों के लिए, सहायता जोड़ने का तरीका जानें: