FirebaseUI की मदद से Android में लॉगिन करना

यह कोडलैब, Kotlin में ऐडवांस Android कोर्स का हिस्सा है. अगर इस कोर्स के कोडलैब को क्रम से पूरा किया जाता है, तो आपको सबसे ज़्यादा फ़ायदा मिलेगा. हालांकि, ऐसा करना ज़रूरी नहीं है. कोर्स के सभी कोडलब, Advanced Android in Kotlin कोडलब के लैंडिंग पेज पर दिए गए हैं.

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

इस सीरीज़ में ये कोडलैब शामिल हैं:

• 6.1 Android Login with FirebaseUI
• 6.2 Android Conditional Navigation with Login

परिचय

Android ऐप्लिकेशन बनाते समय, उपयोगकर्ताओं के लिए लॉगिन करने की सुविधा देने से कई फ़ायदे मिलते हैं. लोगों को अपने ऐप्लिकेशन में पहचान बनाने की अनुमति देकर, उन्हें ऐप्लिकेशन से जुड़ने के ज़्यादा तरीके उपलब्ध कराए जा सकते हैं.

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

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

आपको पहले से क्या पता होना चाहिए

• Android ऐप्लिकेशन बनाने के बारे में बुनियादी जानकारी
• LiveData और ViewModel

आपको क्या सीखने को मिलेगा

• अपने प्रोजेक्ट में Firebase जोड़ने का तरीका
• अपने Android ऐप्लिकेशन में लॉगिन करने की सुविधा कैसे चालू करें
• अपने ऐप्लिकेशन की पुष्टि की मौजूदा स्थिति देखने का तरीका
• उपयोगकर्ताओं को लॉग आउट करने का तरीका

आपको क्या करना होगा

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

LiveData और ViewModel के बारे में ज़्यादा जानें

इस कोडलैब में दिए गए ऐप्लिकेशन के लिए, आपको LiveData और ViewModel के बारे में बुनियादी जानकारी होनी चाहिए. अगर आपको इन कॉन्सेप्ट के बारे में खास जानकारी चाहिए, तो LiveData और ViewModel की खास जानकारी पढ़ें.

इस कोडलैब में शामिल बुनियादी Android विषयों के बारे में जानने के लिए, Developing Android Apps with Kotlin कोर्स भी देखा जा सकता है. यह कोर्स, Udacity कोर्स और codelabs कोर्स, दोनों के तौर पर उपलब्ध है.

इस कोडलैब में, आपको एक ऐसा ऐप्लिकेशन बनाना है जो Android के बारे में मज़ेदार जानकारी दिखाता है. सबसे अहम बात यह है कि ऐप्लिकेशन में लॉगिन/लॉग आउट करें बटन होगा. जब उपयोगकर्ता ऐप्लिकेशन में लॉग इन होता है, तो दिखाए गए किसी भी Android फ़ैक्ट में उपयोगकर्ता के लिए एक ग्रीटिंग शामिल होगी. इससे उपयोगकर्ता को ऐसा लगेगा कि उसे खास तौर पर ध्यान में रखकर जानकारी दी जा रही है.

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

ज़िप फ़ाइल डाउनलोड करें

... या कमांड लाइन से GitHub रिपॉज़िटरी को क्लोन करें. इसके लिए, यहां दी गई कमांड का इस्तेमाल करें. इसके बाद, रिपॉज़िटरी की start ब्रांच पर स्विच करें:

$  git clone https://github.com/googlecodelabs/android-kotlin-login

अहम जानकारी: स्टार्टर कोड, डाउनलोड की गई रेपो की start ब्रांच पर है!

अहम जानकारी: Firebase का इस्तेमाल करने के लिए, आपको ऐप्लिकेशन को इंटिग्रेट करना होगा. इसलिए, स्टार्टर ऐप्लिकेशन को बनाने और चलाने के लिए, कुछ सेटअप करना ज़रूरी है. आपको यह काम, कोडलैब के अगले चरण में करना होगा.

पहला चरण: Firebase प्रोजेक्ट बनाना

अपने Android ऐप्लिकेशन में Firebase जोड़ने से पहले, आपको एक Firebase प्रोजेक्ट बनाना होगा, ताकि उसे अपने Android ऐप्लिकेशन से कनेक्ट किया जा सके.

1. Firebase कंसोल में, प्रोजेक्ट जोड़ें पर क्लिक करें.
2. प्रोजेक्ट का नाम चुनें या डालें. अपने प्रोजेक्ट का नाम कुछ भी रखा जा सकता है. हालांकि, उस ऐप्लिकेशन से मिलता-जुलता नाम चुनें जिसे आपको बनाना है.
3. जारी रखें पर क्लिक करें.
4. Google Analytics को सेट अप करने की प्रोसेस को स्किप किया जा सकता है. इसके लिए, अभी नहीं विकल्प चुनें.
5. Firebase प्रोजेक्ट सेट अप करने की प्रोसेस पूरी करने के लिए, प्रोजेक्ट बनाएं पर क्लिक करें.

दूसरा चरण: अपने ऐप्लिकेशन को Firebase में रजिस्टर करना

अब आपके पास एक Firebase प्रोजेक्ट है. इसमें अपना Android ऐप्लिकेशन जोड़ा जा सकता है.

1. सेटअप वर्कफ़्लो लॉन्च करने के लिए, Firebase कंसोल के प्रोजेक्ट की खास जानकारी वाले पेज के बीच में मौजूद, Android आइकॉन पर क्लिक करें.
2. Android पैकेज का नाम फ़ील्ड में, अपने ऐप्लिकेशन का ऐप्लिकेशन आईडी डालें. पक्का करें कि आपने वही आईडी डाला हो जिसका इस्तेमाल आपका ऐप्लिकेशन कर रहा है. ऐसा इसलिए, क्योंकि Firebase प्रोजेक्ट में ऐप्लिकेशन रजिस्टर करने के बाद, इस वैल्यू को न तो जोड़ा जा सकता है और न ही इसमें बदलाव किया जा सकता है.

1. ऐप्लिकेशन आईडी को कभी-कभी पैकेज का नाम भी कहा जाता है.
2. इस ऐप्लिकेशन आईडी को अपने मॉड्यूल (ऐप्लिकेशन-लेवल) की Gradle फ़ाइल में ढूंढें. आम तौर पर, यह app/build.gradle होता है (उदाहरण के लिए, आईडी: com.yourcompany.yourproject).
3. डीबग साइनिंग सर्टिफ़िकेट का SHA-1 डालें. इस कुंजी को जनरेट करने के लिए, कमांड लाइन टर्मिनल में यह निर्देश डालें.

keytool -alias androiddebugkey -keystore ~/.android/debug.keystore -list -v -storepass android

4. ऐप्लिकेशन रजिस्टर करें पर क्लिक करें.

तीसरा चरण: Firebase कॉन्फ़िगरेशन फ़ाइल को अपने प्रोजेक्ट में जोड़ना

अपने ऐप्लिकेशन में Firebase Android कॉन्फ़िगरेशन फ़ाइल जोड़ें:

1. Firebase Android कॉन्फ़िगरेशन फ़ाइल (google-services.json) पाने के लिए, google-services.json डाउनलोड करें पर क्लिक करें.

• आपके पास किसी भी समय, Firebase Android कॉन्फ़िगरेशन फ़ाइल को फिर से डाउनलोड करने का विकल्प होता है.
• पक्का करें कि कॉन्फ़िगरेशन फ़ाइल में कोई अतिरिक्त वर्ण न जोड़ा गया हो और उसका नाम सिर्फ़ google-services.json होना चाहिए

2. अपनी कॉन्फ़िगरेशन फ़ाइल को अपने ऐप्लिकेशन की मॉड्यूल (ऐप्लिकेशन-लेवल) डायरेक्ट्री में ले जाएं.

चौथा चरण: Firebase प्रॉडक्ट चालू करने के लिए, अपने Android प्रोजेक्ट को कॉन्फ़िगर करना

1. अपने ऐप्लिकेशन में Firebase के प्रॉडक्ट चालू करने के लिए, अपनी Gradle फ़ाइलों में google-services प्लगिन जोड़ें.

1. रूट-लेवल (प्रोजेक्ट-लेवल) की Gradle फ़ाइल (build.gradle) में, Google Services प्लगिन को शामिल करने के लिए नियम जोड़ें. देख लें कि आपके पास Google की मेवन रिपॉज़िटरी भी हो.

build.gradle

buildscript {

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
  }

  dependencies {
    // ...

    // Add the following line:
    classpath 'com.google.gms:google-services:4.3.0'  // Google Services plugin
  }
}

allprojects {
  // ...

  repositories {
    // Check that you have the following line (if not, add it):
    google()  // Google's Maven repository
    // ...
  }
}

2. अपने मॉड्यूल (ऐप्लिकेशन-लेवल) की Gradle फ़ाइल (आम तौर पर app/build.gradle) में, फ़ाइल के सबसे नीचे एक लाइन जोड़ें.

app/build.gradle

apply plugin: 'com.android.application'

android {
  // ...
}

// Add the following line to the bottom of the file:
apply plugin: 'com.google.gms.google-services'  // Google Play services Gradle plugin

चौथा चरण: Firebase डिपेंडेंसी जोड़ना

इस कोडलैब में, Firebase को इंटिग्रेट करने का मुख्य मकसद उपयोगकर्ताओं को बनाने और मैनेज करने का तरीका ढूंढना है. इसके लिए, आपको एक Firebase लाइब्रेरी जोड़नी होगी. इससे आपको लॉगिन की सुविधा लागू करने में मदद मिलेगी.

1. अपने build.gradle (Module:app) फ़ाइल में यह डिपेंडेंसी जोड़ें, ताकि अपने ऐप्लिकेशन में SDK टूल का इस्तेमाल किया जा सके. firebase-auth SDK टूल की मदद से, आपके ऐप्लिकेशन के पुष्टि किए गए उपयोगकर्ताओं को मैनेज किया जा सकता है.

app/build.gradle:

implementation 'com.firebaseui:firebase-ui-auth:5.0.0'

2. अपने प्रोजेक्ट को Gradle फ़ाइलों के साथ सिंक करें, ताकि यह पक्का किया जा सके कि आपके ऐप्लिकेशन के लिए सभी डिपेंडेंसी उपलब्ध हैं. अगर आपको ऐसा करने के लिए कहा नहीं जाता है, तो Android Studio में फ़ाइल > Gradle फ़ाइलों के साथ प्रोजेक्ट सिंक करें को चुनें या टूलबार से चुनें.

पांचवां चरण: ऐप्लिकेशन चलाएं और कोड की जांच करें

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

अगर यह प्रोसेस पूरी हो जाती है, तो आपको होम स्क्रीन पर Android के बारे में एक मज़ेदार फ़ैक्ट दिखेगा. साथ ही, सबसे ऊपर बाईं ओर लॉगिन बटन दिखेगा. लॉगिन बटन पर टैप करने से अभी कुछ नहीं होता.

यह एक सिंगल ऐक्टिविटी वाला ऐप्लिकेशन है, जिसमें कई फ़्रैगमेंट हैं. MainFragment में, आपको नीचे दी गई स्क्रीन पर दिखने वाला पूरा यूज़र इंटरफ़ेस (यूआई) शामिल होता है. (आपको फ़ॉलोअप कोडलैब में LoginFragment और SettingsFragment के साथ काम करना होगा.)

2. कोड के बारे में पूरी जानकारी पाएं. खास तौर पर, इन बातों पर ध्यान दें:

• FirebaseUserLiveData वह क्लास है जिसे आपको लागू करना होगा, ताकि ऐप्लिकेशन से जुड़े मौजूदा Firebase उपयोगकर्ता के बारे में जानकारी मिल सके. आपको FirebaseAuth इंस्टेंस का इस्तेमाल एंट्री पॉइंट के तौर पर करना होगा, ताकि बाद में इस उपयोगकर्ता की जानकारी मिल सके.
• MainFragment, LoginViewModel से जुड़ा है. LoginViewModel वह क्लास है जिसे आपको FirebaseUserLiveData का इस्तेमाल करके authenticationState वैरिएबल बनाने के लिए लागू करना होगा. इस authenticationState वैरिएबल का इस्तेमाल करके, MainFragment वैल्यू को देख सकता है, ताकि यूज़र इंटरफ़ेस (यूआई) को उसके हिसाब से अपडेट किया जा सके.

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

1. Firebase कंसोल पर जाएं. (ध्यान दें: अगर आपको अब भी 'Firebase जोड़ें' वर्कफ़्लो दिख रहा है, तो कंसोल पर वापस जाने के लिए, सबसे ऊपर बाएं कोने में मौजूद X पर क्लिक करें.
2. अगर आपने पहले से अपना प्रोजेक्ट नहीं चुना है, तो उसे चुनें.
3. बाईं ओर मौजूद नेविगेशन बार खोलें और डेवलप करें > पुष्टि करें चुनें.

4. सबसे ऊपर मौजूद नेविगेशन बार में, साइन-इन करने का तरीका टैब चुनें.

5. ईमेल/पासवर्ड लाइन पर क्लिक करें.
6. पॉप-अप में, चालू है स्विच को टॉगल करें. इसके बाद, सेव करें पर क्लिक करें.
7. इसी तरह, Google लाइन पर क्लिक करें.
8. चालू है स्विच को टॉगल करें. इसके बाद, प्रोजेक्ट से जुड़ी सहायता के लिए ईमेल पता डालें और सेव करें पर क्लिक करें.

इस टास्क में, आपको अपने उपयोगकर्ताओं के लिए लॉगिन करने की सुविधा लागू करनी होगी.

1. MainFragment.kt खोलें.
2. MainFragment के लेआउट में, auth_button पर ध्यान दें. फ़िलहाल, इसे किसी भी उपयोगकर्ता के इनपुट को हैंडल करने के लिए सेट अप नहीं किया गया है.
3. onViewCreated(), में, launchSignInFlow() को कॉल करने के लिए auth_button में onClickListener जोड़ें.

MainFragment.kt

binding.authButton.setOnClickListener { launchSignInFlow() }

4. MainFragment.kt में launchSignInFlow() तरीका खोजें. फ़िलहाल, इसमें TODO शामिल है.
5. launchSignInFlow() फ़ंक्शन को नीचे दिखाए गए तरीके से पूरा करें.

MainFragment.kt

private fun launchSignInFlow() {
   // Give users the option to sign in / register with their email or Google account.
   // If users choose to register with their email,
   // they will need to create a password as well.
   val providers = arrayListOf(
       AuthUI.IdpConfig.EmailBuilder().build(), AuthUI.IdpConfig.GoogleBuilder().build()

       // This is where you can provide more ways for users to register and 
       // sign in.
   )

   // Create and launch sign-in intent.
   // We listen to the response of this activity with the
   // SIGN_IN_REQUEST_CODE 
   startActivityForResult(
       AuthUI.getInstance()
           .createSignInIntentBuilder()
           .setAvailableProviders(providers)
           .build(),
       MainFragment.SIGN_IN_REQUEST_CODE
   )
}

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

6. MainFragment.kt में, साइन-इन करने की प्रोसेस का नतीजा सुनने के लिए, onActivityResult() तरीके को लागू किया जा सकता है. इसे यहां दिखाया गया है. आपने SIGN_IN_REQUEST_CODE से साइन इन करने की प्रोसेस शुरू की है. इसलिए, साइन इन करने की प्रोसेस का नतीजा सुनने के लिए, आपको यह फ़िल्टर करना होगा कि SIGN_IN_REQUEST_CODE को वापस onActivityResult() कब भेजा गया. सबसे पहले, कुछ लॉग स्टेटमेंट जोड़ें. इससे यह पता चलेगा कि उपयोगकर्ता ने सही तरीके से साइन इन किया है या नहीं.
   

MainFragment.kt

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
   super.onActivityResult(requestCode, resultCode, data)
   if (requestCode == SIGN_IN_REQUEST_CODE) {
       val response = IdpResponse.fromResultIntent(data)
       if (resultCode == Activity.RESULT_OK) {
           // User successfully signed in
           Log.i(TAG, "Successfully signed in user ${FirebaseAuth.getInstance().currentUser?.displayName}!")
       } else {
           // Sign in failed. If response is null the user canceled the
           // sign-in flow using the back button. Otherwise check
           // response.getError().getErrorCode() and handle the error.
           Log.i(TAG, "Sign in unsuccessful ${response?.error?.errorCode}")
       }
   }
}

अब आपका ऐप्लिकेशन, उपयोगकर्ताओं को रजिस्टर करने और लॉग इन करने की सुविधा दे पाएगा!

7. ऐप्लिकेशन चलाएं और पुष्टि करें कि लॉगिन करें बटन पर टैप करने से, लॉगिन स्क्रीन खुलती है.
8. अब अपने ईमेल पते और पासवर्ड या Google खाते से साइन इन किया जा सकता है.
9. लॉग इन करने के बाद, यूज़र इंटरफ़ेस (यूआई) में कोई बदलाव नहीं होगा. आपको अगले चरण में यूआई को अपडेट करना होगा. हालांकि, अगर सब कुछ ठीक से काम कर रहा है, तो रजिस्ट्रेशन फ़्लो पूरा करने के बाद आपको Successfully signed in user ${your name}! लॉग मैसेज दिखेगा.
10. यह देखने के लिए कि ऐप्लिकेशन में अब एक रजिस्टर किया गया उपयोगकर्ता है, Firebase कंसोल में जाकर, डेवलप > पुष्टि > उपयोगकर्ता पर जाएं.
11. ध्यान दें कि जब उपयोगकर्ता आपके ऐप्लिकेशन के लिए खाता बनाते हैं, तो यह खाता सिर्फ़ आपके ऐप्लिकेशन से जुड़ा होता है. यह किसी ऐसे ऐप्लिकेशन से नहीं जुड़ा होता है जो लॉगिन करने की सुविधा के लिए Firebase का इस्तेमाल करता है.

इस टास्क में, आपको पुष्टि की स्थिति के आधार पर यूज़र इंटरफ़ेस (यूआई) को अपडेट करने की सुविधा लागू करनी होगी. जब उपयोगकर्ता लॉग इन होता है, तब उसकी होम स्क्रीन को मनमुताबिक बनाया जा सकता है. इसके लिए, उस पर उसका नाम दिखाया जा सकता है. जब उपयोगकर्ता लॉग इन कर लेगा, तब आपको लॉगिन करें बटन को लॉग आउट करें बटन के तौर पर अपडेट करना होगा.

1. आपके लिए पहले से बनाई गई FirebaseUserLiveData.kt क्लास खोलें. सबसे पहले, आपको ऐप्लिकेशन में मौजूद अन्य क्लास को यह बताने का तरीका उपलब्ध कराना होगा कि उपयोगकर्ता ने कब लॉग इन या लॉग आउट किया है. हालांकि, LiveData की वैल्यू अपडेट नहीं हो रही है, इसलिए क्लास अभी कुछ नहीं कर रही है.
2. FirebaseAuth लाइब्रेरी का इस्तेमाल किया जा रहा है. इसलिए, लॉग इन किए गए उपयोगकर्ता के डेटा में हुए बदलावों को सुना जा सकता है. इसके लिए, FirebaseUser.AuthStateListener कॉलबैक का इस्तेमाल करें. यह कॉलबैक, FirebaseUI लाइब्रेरी के हिस्से के तौर पर आपके लिए लागू किया गया है. यह कॉलबैक तब ट्रिगर होता है, जब कोई उपयोगकर्ता आपके ऐप्लिकेशन में लॉग इन या लॉग आउट करता है.
3. ध्यान दें कि FirebaseUserLiveData.kt, authStateListener वैरिएबल को तय करता है. इस वैरिएबल का इस्तेमाल, LiveData की वैल्यू को सेव करने के लिए किया जाएगा. authStateListener वैरिएबल इसलिए बनाया गया है, ताकि आप अपने ऐप्लिकेशन की स्थिति के आधार पर, पुष्टि करने की स्थिति में होने वाले बदलावों को सही तरीके से सुनना शुरू और बंद कर सकें. उदाहरण के लिए, अगर उपयोगकर्ता ऐप्लिकेशन को बैकग्राउंड में डालता है, तो ऐप्लिकेशन को पुष्टि करने की स्थिति में होने वाले बदलावों को सुनना बंद कर देना चाहिए. इससे मेमोरी लीक होने से रोका जा सकेगा.
4. authStateListener को अपडेट करें, ताकि आपके FirebaseUserLiveData की वैल्यू, Firebase के मौजूदा उपयोगकर्ता से मेल खाए.

FirebaseUserLiveData.kt

private val authStateListener = FirebaseAuth.AuthStateListener { firebaseAuth ->
   value = firebaseAuth.currentUser
}

5. LoginViewModel.kt खोलें.
6. LoginViewModel.kt में, अभी लागू किए गए FirebaseUserLiveData ऑब्जेक्ट के आधार पर authenticationState वैरिएबल बनाएं. इस authenticationState वैरिएबल को बनाने के बाद, अब अन्य क्लास यह क्वेरी कर सकती हैं कि उपयोगकर्ता ने LoginViewModel के ज़रिए लॉग इन किया है या नहीं.

LoginViewModel.kt

val authenticationState = FirebaseUserLiveData().map { user ->
   if (user != null) {
       AuthenticationState.AUTHENTICATED
   } else {
       AuthenticationState.UNAUTHENTICATED
   }
}

7. MainFragment.kt. खोलें
8. MainFragment.kt के observeAuthenticationState() में, LoginViewModel में अभी-अभी जोड़े गए authenticationState वैरिएबल का इस्तेमाल किया जा सकता है. साथ ही, यूज़र इंटरफ़ेस (यूआई) को इसके हिसाब से बदला जा सकता है. अगर कोई उपयोगकर्ता लॉग इन है, तो authButton को लॉग आउट करें विकल्प दिखाना चाहिए.

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
       when (authenticationState) {
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   // TODO implement logging out user in next step
               }

                // TODO 2. If the user is logged in, 
                 // you can customize the welcome message they see by
                 // utilizing the getFactWithPersonalization() function provided

           }
           else -> {
               // TODO 3. Lastly, if there is no logged-in user, 
                // auth_button should display Login and
                //  launch the sign in screen when clicked.
           }
       }
   })
}

9. अगर उपयोगकर्ता ने लॉग इन किया है, तो MainFragment.
   में दिए गए getFactWithPersonalization() फ़ंक्शन का इस्तेमाल करके, उसे दिखने वाले वेलकम मैसेज को भी पसंद के मुताबिक बनाया जा सकता है.

MainFragment.kt

binding.welcomeText.text = getFactWithPersonalization(factToDisplay)

10. आखिर में, अगर कोई उपयोगकर्ता लॉग इन नहीं है (जब authenticationState, LoginViewModel.AuthenticationState.AUTHENTICATED के अलावा कुछ और हो), तो auth_button को लॉगिन करें दिखाना चाहिए. साथ ही, क्लिक करने पर साइन-इन स्क्रीन लॉन्च करनी चाहिए. साथ ही, दिखाए गए मैसेज को भी लोगों की दिलचस्पी के हिसाब से नहीं बनाया जाना चाहिए.

MainFragment.kt

binding.authButton.text = getString(R.string.login_button_text)
binding.authButton.setOnClickListener { launchSignInFlow() }
binding.welcomeText.text = factToDisplay

सभी चरणों को पूरा करने के बाद, आपकी फ़ाइनल observeAuthenticationState() विधि, नीचे दिए गए कोड की तरह दिखनी चाहिए.

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
        // TODO 1. Use the authenticationState variable you just added 
         // in LoginViewModel and change the UI accordingly.
       when (authenticationState) {
            // TODO 2.  If the user is logged in, 
             // you can customize the welcome message they see by
             // utilizing the getFactWithPersonalization() function provided
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.welcomeText.text = getFactWithPersonalization(factToDisplay)
               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   // TODO implement logging out user in next step
               }
           }
           else -> {
                // TODO 3. Lastly, if there is no logged-in user, 
                 // auth_button should display Login and
                 // launch the sign in screen when clicked.
               binding.welcomeText.text = factToDisplay

               binding.authButton.text = getString(R.string.login_button_text)
               binding.authButton.setOnClickListener {
                   launchSignInFlow()
               }
           }
       }
   })
}

11. अपना ऐप्लिकेशन चलाएं. यूज़र इंटरफ़ेस (यूआई) को इस हिसाब से अपडेट होना चाहिए कि उपयोगकर्ता ने लॉग इन किया है या नहीं. अगर सब कुछ ठीक से काम कर रहा है और आपने लॉग इन किया है, तो होम स्क्रीन पर आपको Android के बारे में एक तथ्य के साथ-साथ, आपका नाम भी दिखेगा. अब लॉगिन करें बटन की जगह लॉग आउट करें बटन दिखना चाहिए.

इस टास्क में, आपको लॉग आउट करने की सुविधा लागू करनी होगी.

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

AuthUI.getInstance().signOut(requireContext())

1. MainFragment.kt खोलें.
2. MainFragment.kt के observeAuthenticationState() में, लॉग आउट करने का लॉजिक जोड़ें, ताकि जब कोई उपयोगकर्ता लॉग इन हो, तब auth_button सही तरीके से काम करे. इस तरीके का फ़ाइनल नतीजा, यहां दिए गए कोड जैसा दिखता है.

MainFragment.kt

private fun observeAuthenticationState() {
   val factToDisplay = viewModel.getFactToDisplay(requireContext())

   viewModel.authenticationState.observe(viewLifecycleOwner, Observer { authenticationState ->
       when (authenticationState) {
           LoginViewModel.AuthenticationState.AUTHENTICATED -> {
               binding.welcomeText.text = getFactWithPersonalization(factToDisplay)

               binding.authButton.text = getString(R.string.logout_button_text)
               binding.authButton.setOnClickListener {
                   AuthUI.getInstance().signOut(requireContext())
               }
           }
           else -> {
               binding.welcomeText.text = factToDisplay

               binding.authButton.text = getString(R.string.login_button_text)
               binding.authButton.setOnClickListener {
                   launchSignInFlow()
               }
           }
       }
   })
}

3. ऐप्लिकेशन चलाएं.
4. Logout बटन पर टैप करें. इसके बाद, पुष्टि करें कि उपयोगकर्ता लॉग आउट हो गया है और बटन की स्थिति बदलकर Login हो गई है.

पूरे ऐप्लिकेशन का फ़ाइनल वर्शन यहां देखा जा सकता है: https://github.com/googlecodelabs/android-kotlin-login.

इस कोडलैब में, आपने इनके बारे में सीखा:

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

इस कोडलैब में, Android ऐप्लिकेशन के लिए लॉगिन की सुविधा देने के तरीके के बारे में बुनियादी जानकारी दी गई है.

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

• FirebaseUI के Authentication से जुड़ा दस्तावेज़
• FirebaseUI Authentication का डेमो और सैंपल कोड

लॉगिन से जुड़े सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, ये अन्य संसाधन देखें:

कोडलैब:

• ऑटोमैटिक भरने की सुविधा के लिए अपने ऐप्लिकेशन को ऑप्टिमाइज़ करना
• Smart Lock की मदद से आसानी से साइन इन करना

Android डेवलपर का दस्तावेज़:

• Android का ऑटोफ़िल फ़्रेमवर्क
• Android पर पासवर्ड के लिए Smart Lock

वीडियो:

• लॉगिन के ज़रिए User Flow को ऑप्टिमाइज़ करना

इस कोर्स में मौजूद अन्य कोडलैब के लिंक के लिए, Advanced Android in Kotlin कोडलैब का लैंडिंग पेज देखें.