इस पेज का अनुवाद Cloud Translation API से किया गया है.

FirebaseUI के साथ Android लॉगिन

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

परिचय

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

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

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

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

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

आप इन चीज़ों के बारे में जानेंगे

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

आप क्या कर पाएंगे!

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

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

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

इस कोडलैब के तहत, आपको Android के उन बुनियादी ऐप्लिकेशन के बारे में जानकारी मिल सकती है जो आपको #39; Android के मौजूदा वर्शन पर मिलेंगे. यह कोर्स Udacity कोर्स और कोडलैब (कोड बनाना सीखना) कोर्स, दोनों के तौर पर उपलब्ध है.

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

सैंपल ऐप्लिकेशन डाउनलोड करें. इसके लिए, इनमें से कोई एक तरीका अपनाएं:

पिन डाउनलोड करें

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

अपने ऐप्लिकेशन में Firebase प्रॉडक्ट को चालू करने के लिए, अपनी Gradle फ़ाइलों में Google की सेवाएं देने वाले प्लग इन को जोड़ें.

अपने रूट-लेवल (प्रोजेक्ट-लेवल) Gradle फ़ाइल (build.gradle) में, Google की सेवाएं प्लग इन शामिल करने के लिए नियम जोड़ें. जांचें कि आपके पास Google&#39 के Maven डेटा स्टोर करने की जगह है.

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
    // ...
  }
}

अपनी मॉड्यूल (ऐप्लिकेशन-लेवल) 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 लाइब्रेरी जोड़नी होगी, जिसकी मदद से लॉगिन किया जा सकता है.

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

app/build.gradle:

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

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

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

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

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

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

कोड के बारे में जानें. खास तौर पर, सूचना:

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

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

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

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

ईमेल/पासवर्ड की लाइन पर क्लिक करें.
पॉप-अप में, चालू स्विच को टॉगल करें और सेव करें पर क्लिक करें.
इसी तरह, Google की पंक्ति पर क्लिक करें.
चालू स्विच को टॉगल करें, प्रोजेक्ट सहायता ईमेल डालें और सेव करें पर क्लिक करें.

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

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

MainFragment.kt

binding.authButton.setOnClickListener { launchSignInFlow() }

launchSignInFlow() में MainFragment.kt वाला तरीका खोजें. फ़िलहाल, इसमें TODO शामिल है.
नीचे दिए गए तरीके से 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 खाते या Google खाते का इस्तेमाल करके, रजिस्ट्रेशन और साइन इन कर सकते हैं. अगर उपयोगकर्ता अपने ईमेल पते के साथ रजिस्टर करने का विकल्प चुनता है, तो उसके बनाए गए ईमेल और पासवर्ड का कॉम्बिनेशन आपके ऐप्लिकेशन के लिए खास होता है. इसका मतलब है कि वह ईमेल पते और पासवर्ड के कॉम्बिनेशन का इस्तेमाल करके आपके ऐप्लिकेशन में लॉगिन कर पाएगा. हालांकि, इसका मतलब यह नहीं है कि वह ऐसे किसी भी क्रेडेंशियल का इस्तेमाल करके, Firebase के साथ काम करने वाले किसी दूसरे ऐप्लिकेशन में लॉगिन कर सकता है.

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}")
       }
   }
}

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

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

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

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

FirebaseUserLiveData.kt

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

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

loginViewModel.kt

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

MainFragment.kt. खोलें
MainFragment.kt's के observeAuthenticationState() में, आप उसी authenticationState वैरिएबल का इस्तेमाल कर सकते हैं जिसे आपने LoginViewModel में अभी जोड़ा है और फिर उसी के हिसाब से यूज़र इंटरफ़ेस (यूआई) बदल सकते हैं. अगर कोई उपयोगकर्ता लॉग इन है, तो 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.
           }
       }
   })
}

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

MainFragment.kt

binding.welcomeText.text = getFactWithPersonalization(factToDisplay)

आखिर में, अगर कोई लॉग इन उपयोगकर्ता नहीं है (जब LoginViewModel.AuthenticationState.AUTHENTICATED के अलावा कोई और authenticationState हो), तो 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()
               }
           }
       }
   })
}

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

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

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

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

MainFragment.kt खोलें.
MainFragment.kt's 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()
               }
           }
       }
   })
}

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

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

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

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

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

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

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

कोडलैब (कोड बनाना सीखना):

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

वीडियो:

लॉगिन के ज़रिए यूज़र फ़्लो को ऑप्टिमाइज़ करना

इस कोर्स में दिए गए दूसरे कोडलैब के लिंक के लिए, Kotlin कोडलैब के लैंडिंग पेज में ऐडवांस्ड Android देखें.