Android Kotlin की बुनियादी बातें 01.3: इमेज से जुड़े संसाधन और इसके साथ काम करने की सुविधा

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

परिचय

इस कोडलैब में, आप पिछले कोडलैब से DiceRoller ऐप्लिकेशन को बेहतर बनाते हैं. साथ ही, अपने ऐप्लिकेशन में इमेज से जुड़े संसाधनों को जोड़ने और इस्तेमाल करने का तरीका जानें. आप Android के अलग-अलग वर्शन में ऐप्लिकेशन के साथ काम करने की सुविधा के बारे में भी जान सकते हैं. साथ ही, यह भी जान सकते हैं कि Android Jetpack कैसे काम करता है.

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

• नया ऐप्लिकेशन प्रोजेक्ट बनाने और एम्युलेटर या फ़िज़िकल डिवाइस पर ऐप्लिकेशन चलाने का तरीका
• ऐप्लिकेशन प्रोजेक्ट के बुनियादी कॉम्पोनेंट, जिनमें संसाधन (res) डायरेक्ट्री और Gradle बिल्ड फ़ाइलें शामिल हैं.
• ऐप्लिकेशन की लेआउट फ़ाइल में बदलाव करने का तरीका.
• अपने ऐप्लिकेशन के कोड में व्यू ऑब्जेक्ट ढूंढने और उनमें बदलाव करने का तरीका.

आप क्या #39;जानेंगे

• अपने ऐप्लिकेशन के संसाधनों में फ़ाइलें जोड़ने का तरीका.
• अपने ऐप्लिकेशन के लेआउट में इमेज का इस्तेमाल कैसे करें.
• अपने ऐप्लिकेशन के कोड में ज़्यादा बेहतर तरीके से व्यू ढूंढने का तरीका.
• एक्सएमएल नेमस्पेस के साथ, अपने ऐप्लिकेशन के डिज़ाइन में प्लेसहोल्डर की इमेज इस्तेमाल करने का तरीका.
• अपने ऐप्लिकेशन के Android एपीआई लेवल के बारे में जानकारी. साथ ही, एपीआई लेवल के कम से कम, टारगेट, और कंपाइल किए गए लेवल को समझने का तरीका.
• Android के पुराने वर्शन के साथ काम करने के लिए, अपने ऐप्लिकेशन में Jetpack लाइब्रेरी का इस्तेमाल कैसे करें.

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

• किसी कोड के बजाय, डाई वैल्यू से जुड़ी इमेज शामिल करने के लिए, पिछले कोडलैब से DiceRoller ऐप्लिकेशन में बदलाव करें.
• अपने ऐप्लिकेशन के संसाधनों में इमेज फ़ाइलें जोड़ें.
• ऐप्लिकेशन के लेआउट और कोड को संख्या के बजाय, डाई वैल्यू से जुड़ी इमेज का इस्तेमाल करने के लिए अपडेट करें.
• ज़्यादा बेहतर तरीके से व्यू पाने के लिए, अपने कोड को अपडेट करें.
• ऐप्लिकेशन शुरू होने पर, किसी खाली इमेज का इस्तेमाल करने के लिए, अपना कोड अपडेट करें.
• Android के पुराने वर्शन के साथ, साथ काम करने के लिए Android Jetpack लाइब्रेरी का इस्तेमाल करने के लिए, अपना ऐप्लिकेशन अपडेट करें.

इस कोडलैब में, आप पिछले कोडलैब में शुरू किए गए DiceRoller ऐप्लिकेशन बनाते हैं और पासे वाली ऐसी इमेज जोड़ते हैं जो बदलने पर बदलती रहती हैं. फ़ाइनल DiceRoller ऐप्लिकेशन ऐसा दिखता है:

अगर आपने पिछले कोडलैब के ज़रिए काम नहीं किया था, तो आप यहां से शुरू करने वाला ऐप्लिकेशन डाउनलोड कर सकते हैं: DiceRoller.

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

पहला चरण: इमेज जोड़ना

1. अगर यह ऐप्लिकेशन पहले से नहीं खुला है, तो Android Studio में DiceRoller ऐप्लिकेशन प्रोजेक्ट खोलें. अगर आपने पिछले कोडलैब के ज़रिए काम नहीं किया था, तो आप यहां से ऐप्लिकेशन डाउनलोड कर सकते हैं: DiceRoller.
2. Project > Android व्यू में, res फ़ोल्डर को बड़ा करें और फिर ड्रॉ करने लायक बड़ा करें.
   
   
   
   आपका ऐप्लिकेशन कई अलग-अलग रिसॉर्स का इस्तेमाल करता है, जिनमें इमेज और आइकॉन, रंग, स्ट्रिंग, और एक्सएमएल लेआउट शामिल हैं. ये सभी संसाधन res फ़ोल्डर में सेव हैं. drawable फ़ोल्डर में आपको अपने ऐप्लिकेशन के लिए इमेज से जुड़े सभी संसाधन दिखाने चाहिए. drawable फ़ोल्डर में, आपको ऐप्लिकेशन के लॉन्चर आइकॉन के लिए, संसाधन पहले से मौजूद हैं.
3. ic_लॉन्चर_Background.xml पर दो बार क्लिक करें. ध्यान दें कि ये एक्सएमएल फ़ाइलें हैं जो आइकॉन की वेक्टर इमेज के तौर पर बताती हैं. वेक्टर्स आपकी इमेज को कई अलग-अलग साइज़ और रिज़ॉल्यूशन में बनाने में मदद करती हैं. PNG या GIF जैसी बिट मैप इमेज को अलग-अलग डिवाइस के लिए स्केल करना पड़ सकता है, जिससे क्वालिटी में कमी आ सकती है.
4. विज़ुअल एडिटर में वेक्टर ड्रॉ करने की सुविधा देखने के लिए, एक्सएमएल एडिटर के दाएं कॉलम में झलक देखें पर क्लिक करें.
   
   
   
5. DiceImages.zip से अपने ऐप्लिकेशन के लिए पासे की इमेज डाउनलोड करें. ZIP फ़ाइल को अनज़िप करें. आपके पास एक्सएमएल फ़ाइलों का एक फ़ोल्डर होगा, जो कुछ ऐसा दिखेगा:

6. Android Studio में, उस प्रोजेक्ट व्यू के सबसे ऊपर मौजूद ड्रॉप-डाउन मेन्यू पर क्लिक करें जिसमें फ़िलहाल Android लिखा है और प्रोजेक्ट चुनें. नीचे दिए गए स्क्रीनशॉट से पता चलता है कि फ़ाइल सिस्टम में आपका ऐप्लिकेशन कैसा दिखता है.
   
   
   
7. DiceRoller > app > src > main > res > Drawable को बड़ा करें.
8. DiceImages फ़ोल्डर से सभी अलग-अलग एक्सएमएल फ़ाइलों को Android Studio में और ड्रॉ करने लायक फ़ोल्डर में खींचें और छोड़ें. ठीक है पर क्लिक करें.

ध्यान दें: पक्का करें कि आप फ़ाइलों को ड्रॉ करने लायक फ़ोल्डर पर छोड़ देते हैं, न कि ड्रॉ करने लायक 24 फ़ोल्डर में. आप इस फ़ोल्डर के बारे में ज़्यादा जानते हैं. साथ ही, आप यह भी जानते हैं कि यह फ़ोल्डर बाद में किस तरह इस्तेमाल किया जाता है.

साथ ही, DiceImages फ़ोल्डर को भी शामिल न करें. सिर्फ़ एक्सएमएल फ़ाइलें खींचें और छोड़ें.

9. प्रोजेक्ट को वापस Android व्यू पर स्विच करें. साथ ही, देखें कि आपकी पासे की इमेज वाली एक्सएमएल फ़ाइलें, ड्रॉ करने लायक फ़ोल्डर में हैं.
10. dice_1.xml पर दो बार क्लिक करें और इस इमेज के लिए एक्सएमएल कोड देखें. वेक्टर ड्रॉ करने की सुविधा कैसी दिखती है, इसकी झलक देखने के लिए झलक देखें बटन पर क्लिक करें.
    
    

दूसरा चरण: इमेज इस्तेमाल करने के लिए लेआउट को अपडेट करना

अब आपके पास अपने res/drawables फ़ोल्डर में पासा वाली इमेज फ़ाइलें हैं, आप अपने ऐप्लिकेशन के लेआउट और कोड से उन फ़ाइलों को ऐक्सेस कर सकते हैं. इस चरण में, आप इमेज दिखाने के लिए संख्याओं को ImageView से दिखाने वाले TextView को बदल देते हैं.

1. अगर activity_main.xml लेआउट फ़ाइल पहले से खुली हुई नहीं है, तो उसे खोलें. लेआउट और #39; एक्सएमएल कोड देखने के लिए टेक्स्ट टैब पर क्लिक करें.
2. <TextView> एलिमेंट मिटाएं.
3. इन एट्रिब्यूट के साथ <ImageView> एलिमेंट जोड़ें:

<ImageView
   android:id="@+id/dice_image"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:src="@drawable/dice_1" />

ImageView का इस्तेमाल, अपने लेआउट में इमेज दिखाने के लिए किया जाता है. इस एलिमेंट के लिए सिर्फ़ एक नई विशेषता है android:src, ताकि इमेज के स्रोत संसाधन के बारे में पता चल सके. इस मामले में, @drawable/dice_1 के इमेज सोर्स का मतलब है कि Android को dice_1 नाम वाली इमेज के ड्रॉ करने लायक रिसॉर्स (res/drawable) में दिखना चाहिए.

4. लेआउट की झलक देखने के लिए, झलक देखें बटन पर क्लिक करें. यह ऐसा दिखना चाहिए:
   
   

तीसरा चरण: कोड अपडेट करना

1. MainActivity खोलें. यहां बताया गया है कि rollDice() फ़ंक्शन अब तक कैसा दिखता है:

private fun rollDice() {
   val randomInt = Random().nextInt(6) + 1

   val resultText: TextView = findViewById(R.id.result_text)
   resultText.text = randomInt.toString()
}

ध्यान दें कि R.id.result_text के संदर्भ को लाल रंग में हाइलाइट किया जा सकता है—यह इसलिए है क्योंकि आपने लेआउट से TextView को मिटा दिया है और वह आईडी अब मौजूद नहीं है.

2. फ़ंक्शन के आखिर में मौजूद दो लाइनें मिटाएं, जो resultText वैरिएबल के बारे में बताती हैं. साथ ही, इसकी टेक्स्ट प्रॉपर्टी सेट करती हैं. अब आप लेआउट में TextView का इस्तेमाल नहीं कर रहे हैं, इसलिए आपको किसी लाइन की ज़रूरत नहीं है.
3. आईडी (R.id.dice_image) के लेआउट में नए ImageView का रेफ़रंस पाने के लिए findViewByID() का इस्तेमाल करें और उस व्यू को नए diceImage वैरिएबल को असाइन करें:

val diceImage: ImageView = findViewById(R.id.dice_image)

4. randomInteger के मान के आधार पर, कोई खास डाई इमेज चुनने के लिए when ब्लॉक जोड़ें:

val drawableResource = when (randomInt) {
   1 -> R.drawable.dice_1
   2 -> R.drawable.dice_2
   3 -> R.drawable.dice_3
   4 -> R.drawable.dice_4
   5 -> R.drawable.dice_5
   else -> R.drawable.dice_6
}

आईडी की तरह ही, आप ड्रॉ करने लायक फ़ोल्डर में पासा वाली इमेज को R क्लास की वैल्यू के साथ देख सकते हैं. R.drawable में, ऐप्लिकेशन और # ड्रॉ करने वाले फ़ोल्डर के बारे में बताया गया है. साथ ही, dice_1 उस फ़ोल्डर में मौजूद डाइ इमेज का खास संसाधन है.

5. ImageView के स्रोत को setImageResource() तरीके और हाल ही में खोजी गई इमेज के रेफ़रंस के साथ अपडेट करें.

diceImage.setImageResource(drawableResource)

6. ऐप्लिकेशन को कंपाइल करें और चलाएं. अब जब आप रोल करें बटन पर क्लिक करेंगे, तो इमेज को सही इमेज के साथ अपडेट कर दिया जाना चाहिए.

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

इस टास्क में, आप अपने ऐप्लिकेशन को और बेहतर बनाने का एक तरीका सीखते हैं.

1. अगर MainActivity पहले से खुला नहीं है, तो उसे खोलें. rollDice() तरीके में, diceImage वैरिएबल के बारे में जानकारी दें:

val diceImage : ImageView = findViewById(R.id.dice_image)

rollDice(), रोल बटन के लिए क्लिक हैंडलर है. इसलिए, जब भी उपयोगकर्ता उस बटन पर टैप करता है, तो आपका ऐप्लिकेशन findViewById() को कॉल करता है और उसे इस ImageView के बारे में जानकारी मिलती है. आदर्श रूप से, आपको findViewById() पर कॉल की संख्या को कम करना चाहिए, क्योंकि Android सिस्टम हर बार पूरे दृश्य पदानुक्रम की खोज कर रहा है और यह एक महंगा ऑपरेशन है.

इस तरह के छोटे से ऐप्लिकेशन में, यह एक बड़ी समस्या नहीं है. अगर आप धीमे #फ़ोन पर ज़्यादा मुश्किल ऐप्लिकेशन चला रहे हैं, तो लगातार findViewById() को कॉल करने से आपका ऐप्लिकेशन रुक सकता है. इसके बजाय, findViewById() को सिर्फ़ एक बार कॉल करना और किसी फ़ील्ड में View ऑब्जेक्ट को सेव करना सबसे सही तरीका है. ImageView में, किसी रेफ़रंस में फ़ील्ड का इस्तेमाल करने से, View किसी भी समय सीधे ऐक्सेस कर सकता है. इससे परफ़ॉर्मेंस बेहतर होती है.

2. क्लास के सबसे ऊपर, onCreate() से पहले, ImageView रखने के लिए एक फ़ील्ड बनाएं.

var diceImage : ImageView? = null

आम तौर पर, इस वैरिएबल को तब ही शुरू किया जाएगा, जब यह एलान किया जाएगा या कंस्ट्रक्टर में. हालांकि, Android की ऐक्टिविटी, कंस्ट्रक्टर का इस्तेमाल नहीं करेंगी. असल में, लेआउट में मौजूद व्यू, मेमोरी में तब तक ऐक्सेस नहीं किए जा सकते, जब तक setContentView() तरीके से onCreate() के तरीके में इनफ़्लेट नहीं हो जाते. जब तक ऐसा नहीं होता, तब तक आप diceImage वैरिएबल को शुरू नहीं कर सकते.

एक विकल्प यह है कि इस वैरिएबल में, diceImage वैरिएबल को शून्य के तौर पर परिभाषित किया जाए. जब null का एलान किया जाता है, तब इसे null पर सेट करें. इसके बाद, findViewById() में onCreate() के असली ImageView को असाइन करें. हालांकि, यह आपका कोड कॉम्प्लेक्स कर देगा, क्योंकि अब आपको हर बार diceImage का इस्तेमाल करने के लिए null वैल्यू की जांच करनी होगी. यहां एक बेहतर तरीका दिया गया है.

3. lateinit कीवर्ड का इस्तेमाल करने और null असाइनमेंट हटाने के लिए, diceImage एलान बदलें:

lateinit var diceImage : ImageView

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

4. onCreate() में, setContentView() तरीके के बाद, ImageView पाने के लिए findViewById() का इस्तेमाल करें.

diceImage = findViewById(R.id.dice_image)

5. rollDice() की पुरानी लाइन को मिटाएं या उसके बारे में ImageView का एलान करें. आपने इस लाइन को पहले फ़ील्ड एलान के साथ बदल दिया है.

val diceImage : ImageView = findViewById(R.id.dice_image)

6. यह देखने के लिए कि ऐप्लिकेशन अब भी ठीक से काम कर रहा है या नहीं, ऐप्लिकेशन को फिर से चलाएं.

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

1. activity_layout.xml को टेक्स्ट टैब में खोलें.
2. <ImageView> एलिमेंट में, android:src एट्रिब्यूट को "@drawable/empty_dice" पर सेट करें:

android:src="@drawable/empty_dice" 

empty_dice इमेज, डाउनलोड की गई इमेज में से एक है और इसे drawable फ़ोल्डर में जोड़ा गया है. यह पास में मौजूद दूसरे पासे की इमेज के साइज़ के बराबर ही होता है. इसमें सिर्फ़ #39 खाली होते हैं. यह इमेज वह है जो ऐप्लिकेशन के पहली बार शुरू होने पर दिखेगी.

3. डिज़ाइन टैब पर क्लिक करें. पासा वाली इमेज अब खाली है, लेकिन यह झलक में भी नहीं दिख रही.
   
   
   
   यह</#39; आम तौर पर, यह होता है कि किसी डिज़ाइन के कॉन्टेंट को रनटाइम के दौरान डाइनैमिक तौर पर दिखाया जाता है. उदाहरण के लिए, ऐसा ऐप्लिकेशन जो खाली या खाली स्क्रीन से शुरू हो सकता है. हालांकि, जब आप किसी ऐप्लिकेशन को लेआउट में किसी तरह का प्लेसहोल्डर डेटा डिज़ाइन करते हैं, तो यह बहुत काम का होता है. इससे आपको पता चलता है कि आप किस तरह का प्लेसहोल्डर डेटा लेआउट में जोड़ रहे हैं.
4. activity_layout.xml में, android:src लाइन कॉपी करें और दूसरी कॉपी चिपकाएं. शब्द "&kot;android&kot;; को " संबंधित/कोटेशन में बदलें", ताकि आपके दोनों एट्रिब्यूट इस तरह दिखें:

android:src="@drawable/empty_dice" 
tools:src="@drawable/empty_dice" />

आपने यहां #&33; इस एट्रिब्यूट के एक्सएमएल नेमस्पेस को डिफ़ॉल्ट android नेमस्पेस से tools नेमस्पेस में बदल दिया है. tools नेमस्पेस का इस्तेमाल तब किया जाता है, जब आप प्लेसहोल्डर कॉन्टेंट के बारे में बताना चाहते हैं. इसका इस्तेमाल सिर्फ़ झलक में या Android Studio में डिज़ाइन एडिटर में किया जाता है. ऐप्लिकेशन को कंपाइल करते समय, tools नेमस्पेस का इस्तेमाल करने वाले एट्रिब्यूट हटा दिए जाते हैं.

नेमस्पेस का इस्तेमाल, एक जैसे नाम वाले एट्रिब्यूट के बारे में बताते समय, किसी बात को आसानी से समझने के लिए किया जाता है. उदाहरण के लिए, <ImageView> टैग के दोनों एट्रिब्यूट का नाम एक ही (src) है, लेकिन नेमस्पेस अलग है.

5. लेआउट फ़ाइल के रूट में <LinearLayout> एलिमेंट की जांच करें और यहां बताए गए दो नेमस्पेस देखें.

<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   ...

6. ImageView टैग में मौजूद tools:src एट्रिब्यूट को बदलकर empty_dice के बजाय dice_1 करें:

android:src="@drawable/empty_dice" 
tools:src="@drawable/dice_1" />

ध्यान दें कि झलक में प्लेसहोल्डर इमेज के तौर पर dice_1 इमेज मौजूद है.

7. ऐप्लिकेशन को कंपाइल करें और चलाएं. ध्यान दें कि जब तक क्लिक करें या रोल करें पर टैप नहीं करते, तब तक असली ऐप्लिकेशन में इमेज खाली रहती है.

Android के लिए डेवलप करने की एक बेहतरीन चीज़ यह है कि आपका कोड कुल कितने डिवाइसों पर चलाया जा सकता है. इनमें Nexus One से लेकर Pixel तक, टैबलेट, Pixelbook, स्मार्ट वॉच, टीवी, और कार जैसे फ़ैक्टर शामिल हैं.

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

इस टास्क में, आप अपने ऐप्लिकेशन को खास Android एपीआई लेवल (वर्शन) के लिए टारगेट करने का तरीका जान सकते हैं. साथ ही, इसमें यह भी बताया गया है कि पुराने डिवाइसों के साथ काम करने के लिए, Android Jetpack लाइब्रेरी का इस्तेमाल कैसे करें.

पहला चरण: एपीआई लेवल के बारे में ज़्यादा जानना

पिछले कोडलैब में, जब आपने अपना प्रोजेक्ट बनाया था, तो आपने बताया था कि आप अपने ऐप्लिकेशन के लिए Android एपीआई का खास लेवल इस्तेमाल कर सकते हैं. Android OS में अलग-अलग वर्शन नंबर होते हैं जिन्हें स्वादिष्ट खाने के नाम से जाना जाता है. ये अक्षर वर्णमाला के क्रम में होते हैं. ओएस का हर वर्शन नई सुविधाओं और फ़ंक्शन के साथ आता है. उदाहरण के लिए, Android Oreo से पिक्चर में पिक्चर ऐप्लिकेशन की सुविधा उपलब्ध कराई गई है, जबकि Android Pi ने स्लाइस को पेश किया है. एपीआई लेवल, Android वर्शन के मुताबिक होते हैं. उदाहरण के लिए, एपीआई 19 का नाम Android 4.4 (KitKat) है.

हार्डवेयर कई चीज़ों के साथ काम करता है, जैसे कि हार्डवेयर किन चीज़ों पर काम करता है, उपयोगकर्ता अपने डिवाइस अपडेट करते हैं या नहीं, और डिवाइस बनाने वाली कंपनियों के लिए अलग-अलग ओएस लेवल काम करते हैं या नहीं. ऐसे उपयोगकर्ताओं के डिवाइस के ओएस वर्शन अलग-अलग होते हैं.

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

1. Gradle स्क्रिप्ट फ़ोल्डर को बड़ा करें और build.gradle (मॉड्यूल: ऐप्लिकेशन) फ़ाइल खोलें.
   
   यह फ़ाइल, ऐप्लिकेशन मॉड्यूल के लिए खास बिल्ड पैरामीटर और डिपेंडेंसी तय करती है. build.gradle (प्रोजेक्ट: DiceRoller) फ़ाइल पूरे प्रोजेक्ट के लिए बिल्ड पैरामीटर तय करती है. कई मामलों में, आपका ऐप्लिकेशन मॉड्यूल आपके प्रोजेक्ट का इकलौता मॉड्यूल होता है. इसलिए, यह विभाजन मनमाना लग सकता है. हालांकि, अगर आपका ऐप्लिकेशन ज़्यादा जटिल हो जाता है और आप इसे कई हिस्सों में बांटते हैं या अगर आपका ऐप्लिकेशन Android स्मार्टवॉच जैसे प्लैटफ़ॉर्म पर काम करता है, तो हो सकता है कि आपको एक ही प्रोजेक्ट में अलग-अलग मॉड्यूल दिखें.
2. build.gradle फ़ाइल के सबसे ऊपर मौजूद android सेक्शन की जांच करें. (नीचे दिया गया नमूना पूरा सेक्शन नहीं है, लेकिन इसमें यह शामिल है कि आप इस कोडलैब के लिए किस चीज़ में सबसे ज़्यादा दिलचस्पी रखते हैं.)

android {
   compileSdkVersion 28
   defaultConfig {
       applicationId "com.example.android.diceroller"
       minSdkVersion 19
       targetSdkVersion 28
       versionCode 1
       versionName "1.0"
   }

3. compileSdkVersion पैरामीटर की जांच करें.

compileSdkVersion 28

यह पैरामीटर उस Android एपीआई लेवल के बारे में बताता है जिसे Gradle को आपके ऐप्लिकेशन को कंपाइल करने के लिए इस्तेमाल करना चाहिए. यह Android का वह नया वर्शन है जिस पर आपका ऐप्लिकेशन काम कर सकता है. इसका मतलब है कि आपका ऐप्लिकेशन, इस एपीआई लेवल और उससे पहले के वर्शन में शामिल एपीआई सुविधाओं का इस्तेमाल कर सकता है. इस मामले में आपके ऐप्लिकेशन में एपीआई 28 का इस्तेमाल किया जाता है, जो Android 9 (पाई) से जुड़ा होता है.

4. targetSdkVersion सेक्शन की जांच करें, जो defaultConfig सेक्शन में है:

targetSdkVersion 28

यह वह सबसे नया एपीआई है जिसके ज़रिए आपने अपने ऐप्लिकेशन की जांच की है. कई मामलों में, यह वैल्यू compileSdkVersion के बराबर होती है.

5. minSdkVersion पैरामीटर की जांच करें.

minSdkVersion 19

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

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

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

दूसरा चरण: साथ काम करने से जुड़ी जानकारी पाना

Android डेवलपर के अलग-अलग लेवल के लिए लिखना, ऐप्लिकेशन डेवलपर के सामने एक सामान्य चुनौती है. इसलिए, Android फ़्रेमवर्क टीम ने आपकी मदद के लिए बहुत काम किया है.

साल 2011 में, टीम ने पहली सहायता लाइब्रेरी जारी की थी. यह लाइब्रेरी, Google ने डेवलप की है और इसके साथ काम करने वाली क्लास और काम करने वाले फ़ंक्शन हैं. Google ने 2018 में, Android Jetpack का एलान किया था. यह लाइब्रेरी का एक ऐसा कलेक्शन है जिसमें पिछली लाइब्रेरी और सहायता लाइब्रेरी के कई फ़ंक्शन शामिल हैं. साथ ही, इसमें सहायता लाइब्रेरी का दायरा भी बढ़ाया जा रहा है.

1. MainActivity खोलें.
2. ध्यान दें कि आपकी MainActivity क्लास Activity से नहीं, बल्कि AppCompatActivity से बढ़ती है.

class MainActivity : AppCompatActivity() { 
...

AppCompatActivity, साथ काम करने की एक ऐसी क्लास है जो यह पक्का करती है कि अलग-अलग प्लैटफ़ॉर्म ओएस लेवल पर आपकी गतिविधि एक जैसी दिखे.

3. अपनी लाइन के इंपोर्ट को बढ़ाने के लिए, import से शुरू होने वाली लाइन के बगल में मौजूद + के निशान पर क्लिक करें. ध्यान दें कि AppCompatActivity क्लास, androidx.appcompat.app पैकेज से इंपोर्ट की गई है. Android Jetpack लाइब्रेरी का नेमस्पेस androidx है.
4. build.gradle (मॉड्यूल: ऐप्लिकेशन) खोलें और नीचे डिपेंडेंसी सेक्शन तक स्क्रोल करें.

dependencies {
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
   implementation 'androidx.appcompat:appcompat:1.0.0-beta01'
   implementation 'androidx.core:core-ktx:1.0.1'
   implementation 'androidx.constraintlayout:constraintlayout:1.1.2'
   testImplementation 'junit:junit:4.12'
   androidTestImplementation 'androidx.test:runner:1.1.0-alpha4'
   androidTestImplementation 
        'androidx.test.espresso:espresso-core:3.1.0-alpha4'
}

appcompat लाइब्रेरी पर निर्भरता पर ध्यान दें. यह androidx का हिस्सा है और इसमें AppCompatActivity क्लास शामिल है.

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

तीसरा चरण: वेक्टर ड्रॉबल के लिए काम करने की सुविधा जोड़ना

आप अपने ऐप्लिकेशन में एक आखिरी बदलाव करने के लिए नेमस्पेस, Gradle, और कम्पैटबिलटी के बारे में नई जानकारी का इस्तेमाल करेंगे. इससे पुराने प्लैटफ़ॉर्म पर, आपके ऐप्लिकेशन का साइज़ ऑप्टिमाइज़ हो जाएगा.

1. res फ़ोल्डर को बड़ा करें और फिर ड्रॉ करने लायक को बड़ा करें. किसी डाई इमेज पर दो बार क्लिक करें.
   
   जैसा कि आपने पहले सीखा, पासे वाली सभी इमेज असल में एक्सएमएल फ़ाइलें हैं, जो पासे के रंग और आकार परिभाषित करती हैं. इस तरह की फ़ाइलों को वेक्टर ड्रॉबल कहा जाता है. वेक्टर ड्रॉबल बनाम PNG (इमेज) जैसे बिट मैप इमेज फ़ॉर्मैट के बारे में सबसे अच्छी बात यह है कि वेक्टर ड्रॉ करने की सुविधा, क्वालिटी बनाए बिना स्केल कर सकती है. साथ ही, वेक्टर ड्रॉ करने की सुविधा, आम तौर पर बिट मैप के फ़ॉर्मैट में एक ही इमेज से बहुत छोटी होती है.
   
   ध्यान खींचने वाली ड्रॉ करने की सुविधा के बारे में ध्यान देने वाली ज़रूरी बात यह है कि एपीआई, 21 के बाद वाले वर्शन में काम कर सकते हैं. हालांकि, आपके ऐप्लिकेशन का कम से कम SDK टूल, एपीआई 19 पर सेट है. अगर आपने एपीआई 19 डिवाइस या एम्युलेटर पर अपने ऐप्लिकेशन को आज़माया है, तो आप देख पाएंगे कि ऐप्लिकेशन ठीक से काम कर रहा है. तो यह कैसे काम करता है?
   
   जब आप अपना ऐप्लिकेशन बनाते हैं, तो Gradle बिल्ड प्रोसेस हर वेक्टर फ़ाइल से PNG फ़ाइल जनरेट करता है. साथ ही, उन PNG फ़ाइलों को 21 साल से कम उम्र के किसी भी Android डिवाइस में इस्तेमाल किया जाता है. ये अतिरिक्त PNG फ़ाइलें आपके ऐप्लिकेशन के आकार को बढ़ा देती हैं. बेवजह बड़े ऐप्लिकेशन # बड़े ऐप्लिकेशन के अनइंस्टॉल होने की संभावना भी ज़्यादा होती है. साथ ही, ऐसे उपयोगकर्ता जो उन ऐप्लिकेशन के डाउनलोड को डाउनलोड या रद्द नहीं कर पाते.
   
   अच्छी खबर यह है कि एपीआई लेवल 7 पर वापस जाने के लिए वेक्टर ड्रॉअर के लिए Android X के साथ काम करने वाली लाइब्रेरी मौजूद है.
2. build.gradle (मॉड्यूल: ऐप्लिकेशन) खोलें. इस सेक्शन को defaultConfig सेक्शन में जोड़ें:

vectorDrawables.useSupportLibrary = true

3. अभी सिंक करें बटन पर क्लिक करें. जब भी build.gradle फ़ाइल में बदलाव किया जाता है, तो आपको बिल्ड फ़ाइलें सिंक करनी होती हैं.
4. main_activity.xml लेआउट फ़ाइल खोलें. इस नेमस्पेस को tools नेमस्पेस के नीचे, <LinearLayout> टैग में जोड़ें:

xmlns:app="http://schemas.android.com/apk/res-auto"

app नेमस्पेस, उन एट्रिब्यूट के लिए है जो आपके कस्टम कोड या लाइब्रेरी से मिलते हैं, न कि Android के मुख्य फ़्रेमवर्क से.

5. <ImageView> एलिमेंट में मौजूद android:src एट्रिब्यूट को बदलकर app:srcCompat करें.

app:srcCompat="@drawable/empty_dice"

app:srcCompat एट्रिब्यूट, Android X के पुराने वर्शन में वेक्टर ड्रॉबल के साथ काम करने के लिए, Android X लाइब्रेरी का इस्तेमाल करता है. यह पुराने एपीआई लेवल 7 पर काम करता है.

6. अपना ऐप्लिकेशन बनाएं और चलाएं. आपको स्क्रीन पर कुछ भी अलग नज़र नहीं आएगा, लेकिन अब आपके ऐप्लिकेशन को पासा वाली इमेज के लिए जनरेट की गई PNG फ़ाइलें इस्तेमाल करने की ज़रूरत नहीं है. भले ही, आपकी दौड़ एक भी छोटी ऐप्लिकेशन फ़ाइल हो.

Android Studio प्रोजेक्ट: DiceRollerfinal

ध्यान दें: कोडिंग की सभी चुनौतियां वैकल्पिक हैं.

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

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

private fun getRandomDiceImage() : Int { ... }

कोडिंग चुनौती के समाधान का कोड

Android Studio प्रोजेक्ट: DiceRollerLast-Challenge

ऐप्लिकेशन के रिसॉर्स:

• आपके ऐप्लिकेशन के रिसॉर्स में इमेज और आइकॉन, ऐप्लिकेशन में इस्तेमाल किए जाने वाले स्टैंडर्ड रंग, स्ट्रिंग, और एक्सएमएल लेआउट शामिल हो सकते हैं. ये सभी संसाधन res फ़ोल्डर में सेव किए गए हैं.
• drawable संसाधन फ़ोल्डर वह है जहां आपको अपने ऐप्लिकेशन के लिए सभी इमेज संसाधन रखने चाहिए.

इमेज व्यू में वेक्टर ड्रॉबल का इस्तेमाल करना:

• वेक्टर ड्रॉ करने लायक इमेज, एक्सएमएल फ़ॉर्मैट में बताई गई इमेज हैं. वेक्टर ड्रॉइंग, बिट मैप इमेज (जैसे कि PNG फ़ाइलें) की तुलना में ज़्यादा सुविधाजनक होती हैं, क्योंकि उन्हें किसी भी साइज़ या रिज़ॉल्यूशन में छोटा किया जा सकता है.
• अपने ऐप्लिकेशन के लेआउट में ड्रॉ करने के लिए, <ImageView> एलिमेंट का इस्तेमाल करें. इमेज का स्रोत android:src एट्रिब्यूट में है. ड्रॉ करने लायक संसाधन फ़ोल्डर देखने के लिए, @drawable का इस्तेमाल करें, जैसे कि "@drawable/image_name".
• इमेज के लिए अपने MainActivity कोड में ImageView व्यू का इस्तेमाल करें. आप व्यू' की इमेज को किसी दूसरे रिसॉर्स में बदलने के लिए setImageResource() का इस्तेमाल कर सकते हैं. ड्रॉ करने लायक खास चीज़ें बताने के लिए, R.drawable का इस्तेमाल करें. उदाहरण के लिए, setImageResource(R.drawable.image_name).

lateinit कीवर्ड:

• अपने कोड में findViewById() के लिए कॉल को कम करें. इसके लिए, फ़ील्ड को एलान करें कि आप उन व्यू को होल्ड करना चाहते हैं. साथ ही, फ़ील्ड को onCreate() में शुरू करें. फ़ील्ड के लिए lateinit कीवर्ड इस्तेमाल करें, ताकि उसे शून्य होने का एलान करने से बचा जा सके.

डिज़ाइन के समय एट्रिब्यूट के लिए tools नेमस्पेस:

• सिर्फ़ Android Studio' झलक या डिज़ाइन एडिटर में इमेज दिखाने के लिए, अपने लेआउट में <ImageView> एलिमेंट में tools:src एट्रिब्यूट का इस्तेमाल करें. इसके बाद, आप फ़ाइनल ऐप्लिकेशन के लिए android:src में एक खाली इमेज का इस्तेमाल कर सकते हैं.
• Android Studio में लेआउट के लिए प्लेसहोल्डर कॉन्टेंट या संकेत बनाने के लिए, Android लेआउट फ़ाइल में tools नेमस्पेस का इस्तेमाल करें. tools एट्रिब्यूट के ज़रिए बताया गया डेटा, आखिरी ऐप्लिकेशन में इस्तेमाल नहीं किया जाता.

एपीआई लेवल:

• हर Android OS का एक आधिकारिक वर्शन नंबर और नाम होता है (उदाहरण के लिए, Android 9.0, "Pie&QUt;) और एक एपीआई लेवल (एपीआई 28). आपके ऐप्लिकेशन पर काम करने वाले Android वर्शन के बारे में बताने के लिए, अपने ऐप्लिकेशन की Gradle फ़ाइलों में एपीआई लेवल का इस्तेमाल करें.
• build.gradle फ़ाइल में compileSdkVersion पैरामीटर से उस Android एपीआई लेवल के बारे में पता चलता है जिसका इस्तेमाल Gradle को आपके ऐप्लिकेशन को कंपाइल करने के लिए करना चाहिए.
• वह targetSdkVersion पैरामीटर बताता है जो उस हाल के एपीआई लेवल का इस्तेमाल करता है जिससे आपने अपने ऐप्लिकेशन की जांच की है. कई मामलों में इस पैरामीटर का मान compileSdkVersion के समान होता है.
• minSdkVersion पैरामीटर, आपके ऐप्लिकेशन के पुराने एपीआई लेवल की जानकारी देता है.

Android Jetpack:

• Android Jetpack लाइब्रेरी का एक संग्रह है जिसे Google ने डेवलप किया है. यह Android के पुराने वर्शन के साथ काम करने के लिए पुराने सिस्टम के साथ काम करता है. साथ ही, इनके साथ काम करता है. Jetpack, लाइब्रेरी के उस सेट की जगह लेता है और बड़ा करता है जिसे पहले Android सपोर्ट लाइब्रेरी कहा जाता था.
• androidx पैकेज से इंपोर्ट की गई क्लास, Jetpack लाइब्रेरी की जानकारी देती हैं. आपकी build.gradle फ़ाइल में Jetpack के डिपेंडेंसी भी androidx से शुरू होती हैं.

वेक्टर ड्रॉबल के लिए पुराने सिस्टम के साथ काम करने की सुविधा:

• वेक्टर ड्रॉबल सिर्फ़ एपीआई के 21 वर्शन से ऊपर के वर्शन में काम करते हैं. पुराने वर्शन में, Gradle ऐप्लिकेशन के तैयार होने पर, ड्रॉबल के लिए PNG इमेज जनरेट करता है.
• यह बताया जा सकता है कि Android सहायता लाइब्रेरी का इस्तेमाल, पुराने एपीआई वर्शन में वेक्टर ड्रॉबल के लिए किया जाना चाहिए. ऐसा build.gradle फ़ाइल में vectorDrawables.useSupportLibrary = true कॉन्फ़िगरेशन पैरामीटर के साथ किया जा सकता है.
• जब आप app:srcCompat#

app नेमस्पेस:

• आपकी एक्सएमएल लेआउट फ़ाइल में app नेमस्पेस, उन एट्रिब्यूट के लिए है जो आपके कस्टम कोड या लाइब्रेरी से आते हैं, न कि Android के मुख्य फ़्रेमवर्क से.

Udcity कोर्स:

• Kotlin के साथ Android ऐप्लिकेशन डेवलप करना

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

• ImageView
• ऐप्लिकेशन के संसाधनों के बारे में खास जानकारी
• findViewById()
• टूल एट्रिब्यूट के बारे में जानकारी
• अलग-अलग प्लैटफ़ॉर्म वर्शन के साथ काम करना
• एपीआई लेवल से जुड़ी ज़रूरी शर्तें बताना
• Android Jetpack

अन्य:

• देर से शुरू होने वाली प्रॉपर्टी और वैरिएबल
• बिल्ड को कॉन्फ़िगर करना

इस सेक्शन में उन छात्र-छात्राओं के लिए गृहकार्य की असाइनमेंट की सूची दी गई है जो इस कोडलैब के ज़रिए एक शिक्षक की देखरेख में कोर्स में काम कर रहे हैं. यह क्रिएटर का काम #33 पर निर्भर करता है:

• अगर ज़रूरी हो, तो होमवर्क असाइन करें.
• छात्र-छात्राओं को होमवर्क के असाइनमेंट सबमिट करने के तरीके के बारे में बताएं.
• होमवर्क असाइनमेंट को ग्रेड दें.

शिक्षक इन सुझावों का इस्तेमाल जितनी चाहें उतनी कम या ज़्यादा कर सकते हैं. साथ ही, उन्हें अपने हिसाब से कोई भी होमवर्क असाइन करना चाहिए.

अगर आप इस कोडलैब के ज़रिए खुद काम कर रहे हैं, तो बेझिझक इन होमवर्क असाइनमेंट का इस्तेमाल करें.

ऐप्लिकेशन बदलना

DiceRoller ऐप्लिकेशन में एक हटाएं बटन जोड़ें, जो डाई इमेज को वापस खाली इमेज पर सेट करता है.

इन सवालों के जवाब दें

पहला सवाल

कौनसा <ImageView> एट्रिब्यूट उस सोर्स इमेज के बारे में बताता है जिसे सिर्फ़ Android Studio में इस्तेमाल किया जाना चाहिए?

• android:srcCompat
• app:src
• tools:src
• tools:sourceImage

दूसरा सवाल

Kotlin कोड में ImageView का इमेज रिसॉर्स कैसे बदलता है? xmx

• setImageResource()
• setImageURI()
• setImage()
• setImageRes()

तीसरा सवाल

वैरिएबल एलान में, lateinit कीवर्ड से क्या पता चलता है?

• वैरिएबल कभी भी शुरू नहीं किया गया.
• वैरिएबल सिर्फ़ ऐप्लिकेशन रनटाइम पर शुरू किया जाता है.
• वैरिएबल null में अपने-आप शुरू हो जाता है.
• वैरिएबल बाद में शुरू किया जाएगा. मैं वादा करता/करती हूं!

चौथा सवाल

Gradle कॉन्फ़िगरेशन को हाल ही में, किस एपीआई लेवल के साथ टेस्ट किया गया है?

• minSdkVersion
• compileSdkVersion
• targetSdkVersion
• testSdkVersion

पांचवां सवाल

आपको अपने कोड में एक इंपोर्ट लाइन दिखती है, जो androidx से शुरू होती है. इसका क्या अर्थ है?

• क्लास, Android Jetpack लाइब्रेरी का हिस्सा है.
• क्लास किसी बाहरी लाइब्रेरी में है, जो ऐप्लिकेशन के चलने पर डाइनैमिक रूप से लोड होगी.
• कक्षा &kot;extra&kot; और आपकी कक्षा के लिए वैकल्पिक है.
• क्लास, Android और #39; XML एक्सएमएल सपोर्ट का हिस्सा है.

ग्रेड देने के लिए अपना ऐप्लिकेशन सबमिट करना

पक्का करें कि ऐप्लिकेशन में ये चीज़ें मौजूद हों:

• ऐप्लिकेशन के लेआउट में एक इमेज व्यू और दो बटन होने चाहिए.
• ऐप्लिकेशन के कोड को दो क्लिक हैंडलर सेट करने चाहिए, हर बटन के लिए एक.
• मिटाएं बटन के क्लिक हैंडलर को, डाई इमेज को R.drawable.empty_dice पर सेट कर देना चाहिए.

अगला लेसन शुरू करें: 1.4: खुद की मदद करना सीखें

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