Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रणाली >> Android

एंड्रॉइड ऐप डेवलपमेंट की शुरुआती गाइड: स्क्रैच से ऐप्स बनाएं

सभी फोन्स में से 75% एंड्रॉइड फोन हैं और सभी इंटरनेट यूजर्स में से 75% केवल अपने फोन से इंटरनेट एक्सेस करते हैं। इसलिए एंड्रॉइड ऐप्स के लिए एक बड़ा बाजार है।

हमने freeCodeCamp.org के YouTube चैनल पर एंड्रॉइड ऐप डेवलपमेंट का एक क्रैश कोर्स पब्लिश किया है। यह कोर्स उन लोगों के लिए एकदम सही है जो एंड्रॉइड ऐप डेवलपमेंट में बिल्कुल नए हैं।

यह कोर्स Rahul Pandey ने विकसित किया है। Rahul Facebook में Android Lead हैं और Stanford University में लेक्चरर हैं।

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

आप XML के साथ यूजर इंटरफेस बनाना और Kotlin प्रोग्रामिंग लैंग्वेज का उपयोग करके लॉजिक कोड करना सीखेंगे। ये किसी भी आधुनिक एंड्रॉइड ऐप के fundamental building blocks हैं।

आप ConstraintLayout का उपयोग करना और ऐप लॉजिक के लिए दो इवेंट लिसनर सीखेंगे। बेस अमाउंट और टिप पर्सेंटेज डालने के बाद, ऐप आपके लिए टिप और टोटल कैलकुलेट करेगा। आप टिप पर्सेंटेज एनिमेशन और फुटर भी इम्प्लीमेंट करेंगे ताकि ऐप और यूनिक बने।

नीचे दिए गए वीडियो को देखें या freeCodeCamp.org YouTube चैनल पर (1 घंटे का वॉच)।

ट्रांसक्रिप्ट

(ऑटोजेनरेटेड)

इस beginner's कोर्स में, आप Rahul Pandey से एंड्रॉइड ऐप बनाना सीखेंगे।

Rahul Facebook में Android engineer हैं और Stanford University में लेक्चरर हैं। हम शुरुआत से एक एंड्रॉइड ऐप बनाएंगे – खाली प्रोजेक्ट से शुरू करके कुछ ऐसा बनाएंगे जिसे आप वास्तव में उपयोग कर सकें, और यहां तक कि Play Store पर पब्लिश भी कर सकें। हम एक टिप कैलकुलेटर बनाएंगे, जहां आप बेस अमाउंट, टिप पर्सेंटेज डाल सकते हैं, और ऐप आपके लिए टिप और टोटल अमाउंट कैलकुलेट करेगा।

हम इस ऐप को Kotlin प्रोग्रामिंग लैंग्वेज का उपयोग करके बनाएंगे।

तो मैं मानकर चल रहा हूं कि आपको प्रोग्रामिंग में कुछ बैकग्राउंड है।

लेकिन अगर आप Kotlin में नए हैं, तो मैं description में एक क्विक 12-मिनट के प्राइमर का लिंक छोड़ दूंगा जो मैंने बनाया है।

मैं Rahul हूं, मैं कुछ समय से YouTube पर और उसके बाहर एंड्रॉइड पढ़ा रहा हूं।

तो जब आप तैयार हों, तो आइए इसमें कूदते हैं और साथ मिलकर यह ऐप बनाते हैं।

इस वीडियो में मैं तीन चीजें कवर करना चाहता हूं।

पहला, मैं टिप कैलकुलेटर एप्लिकेशन के मुख्य फीचर्स के बारे में बताऊंगा।

दूसरा, मैं उन core Android concepts को समझाऊंगा जिन्हें हम इसे बनाते समय कवर करेंगे।

और तीसरा, क्योंकि मैं ऐप को जानबूझकर बहुत सिंपल रख रहा हूं, मैं उन Android concepts को भी बताना चाहता हूं जिनका सामना हम इसे बनाते समय नहीं करेंगे।

और उनको बाद में ज्यादा sophisticated या complicated Android apps में कवर किया जाएगा।

मैंने पहले बताया था कि आप इस ऐप को ट्यूटोरियल खत्म करते ही Google Play Store पर पब्लिश कर सकते हैं।

और मैंने ठीक ऐसा ही किया।

तो अगर आप यह देखना चाहते हैं कि हम क्या बनाने वाले हैं, तो description में लिंक चेक करें और अपने किसी एंड्रॉइड डिवाइस पर डाउनलोड करें।

चलिए ऐप का डेमो करते हैं ताकि हमें उन मुख्य फीचर्स का अंदाजा हो जाए जिन्हें हम बनाने वाले हैं।

इस उदाहरण में, मैं एक बहुत शानदार सोलो डिनर के लिए गया था, और मैंने $83.15 खर्च किए।

और मैं 24% की काफी generous tip छोड़ रहा हूं और ऐप ऑटोमैटिकली टिप और टोटल अमाउंट कैलकुलेट करता है।

मैथ को थोड़ा आसान बनाने के लिए, बेस अमाउंट को $100 अपडेट करते हैं।

और आप देख सकते हैं, जो कीबोर्ड आता है वह केवल नंबर्स और डेसिमल इनपुट करने की अनुमति देता है, जो समझ में आता है क्योंकि हम currencies के साथ डील कर रहे हैं।

और अगर मैं सर्विस से बहुत खुश हूं, तो मैं टिप पर्सेंटेज बढ़ाकर maximum 30% तक ले जा सकता हूं।

और यहां दो चीजें होती हैं।

पहला, हम dynamically टिप और टोटल अमाउंट computations को 30 पर अपडेट करते हैं। और sum 130 है।

लेकिन साथ ही, हम उस टिप पर्सेंटेज के description को भी अपडेट करते हैं।

तो यह "great" से "amazing" हो गया और यह brighter green color भी बन गया।

दूसरी तरफ, अगर मैं सर्विस से बहुत नाखुश था, तो मैं zero tip दे सकता हूं।

और हम उसे poor tip मानते हैं।

और आप देख सकते हैं कि color red हो गया।

और फिर नीचे footer में, हमारे पास ऐप को पर्सनलाइज करने का एक तरीका है ताकि आप बता सकें कि इसे किसने बनाया या आप कहां से हैं।

टिप कैलकुलेटर में हम जिन concepts को कवर करते हैं, वही concepts हर एंड्रॉइड ऐप के लिए fundamental हैं।

पहला है UI बनाना।

हर ऐप को यूजर इंटरफेस की जरूरत होती है।

और जिस core component का हम यहां उपयोग करेंगे वह है ConstraintLayout, जिसमें दूसरे विजेट्स होंगे, जैसे TextView, या टिप पर्सेंटेज डालने के लिए SeekBar।

दूसरा, हर interesting एंड्रॉइड ऐप यूजर इनपुट को सुनेगा और उस पर react करेगा।

तो हमारे ऐप में डेटा इनपुट करने के दो तरीके हैं – एक बेस अमाउंट डालना, और दूसरा टिप पर्सेंटेज।

और उसके आधार पर हमें react करके UI को appropriately अपडेट करना होगा।

और तीसरा, हम Android पर styling और animation की सतह को बस छूएंगे – मैं आपको दिखाऊंगा कि कुछ colors को कैसे अपडेट करें और टिप description के साथ एनिमेशन कैसे करें और उसका कलर dynamically कैसे बदलें।

टिप कैलकुलेटर में बहुत कुछ ऐसा भी है जिसे हम कवर नहीं करेंगे।

और scope को reduce करके इस ऐप को really quick और simple to build बनाने के लिए यह important है।

अगर आप Android में नए हैं, तो पहले, हमारे पास multiple screens नहीं होंगे।

जिसका मतलब है कि हमें navigation या Android में back stack जैसी चीजों से डील नहीं करना पड़ेगा।

और वास्तव में, हमारे पास जो single screen है वह भी काफी सिंपल है, क्योंकि हमारे पास कोई list data नहीं है जिसे manage करना पड़े।

दूसरा, हमारा networking या internet से कोई लेना-देना नहीं है।

जैसे ही आप API या server से बात करना शुरू करते हैं, चीजें काफी complicated हो जाती हैं क्योंकि आपको asynchronous programming और उस डेटा को manage करना पड़ता है।

और तीसरा, हम storage के साथ भी बिल्कुल डील नहीं कर रहे – सब कुछ local और in-memory होगा।

तो हम database या disk या cloud में कहीं भी write नहीं करेंगे।

और ये तीनों चीजें ऐप को build करना बहुत सरल बनाती हैं।

तो मुझे यकीन है कि जब आप इसे बनाएंगे और किसी रेस्टोरेंट में जाएंगे, तो आप super popular होंगे क्योंकि आप टिप easily calculate कर पाएंगे और literally आपका नाम ऐप पर होगा।

तो मैं आपको अगले वीडियो में मिलूंगा।


इस वीडियो में, हम बिल्कुल नए Android Studio प्रोजेक्ट से शुरू करके अपने टिप कैलकुलेटर के लिए views layout करेंगे। विशेष रूप से, हम आठ views layout करेंगे जहां बाईं ओर के चार TextViews दाईं ओर दिखाए जा रहे कंटेंट को describe करेंगे।

पहली चीज जो हम करेंगे वह है एक बिल्कुल नया Android Studio प्रोजेक्ट बनाना।

मेरे पास Android Studio चल रहा है, और मैं Arctic Fox चला रहा हूं, लेकिन कोई भी recent version काम करेगा। New Project पर टैप करें।

और मैं Empty Activity template चुनूंगा।

ये दूसरे templates कभी-कभी useful होते हैं, लेकिन ये हमारे एप्लिकेशन में बहुत सारा cruft ले आते हैं, जो confusing हो सकता है।

तो usually, मैं just Empty Activity के साथ जाता हूं।

आइए अपने एप्लिकेशन को Tippie कहते हैं।

Package name, usually मैं क्या करता हूं कि मैं अपना domain name या email address लेता हूं और उसे उल्टा कर देता हूं।

तो मैं उसे as is छोड़ दूंगा और फिर एक location चुनूंगा, सुनिश्चित करें कि Kotlin select किया हुआ है language के लिए।

और मैं minimum SDK version API 21 चुनूंगा।

अब Finish पर टैप करूंगा।

और जब भी मेरे पास एक बिल्कुल नया प्रोजेक्ट होता है तो मैं सबसे पहले जो करना पसंद करता हूं वह है simply starter code को run करने की कोशिश करना।

क्योंकि अगर हम starter code भी नहीं चला सकते, तो कुछ पहले से ही गलत है।

आइए सुनिश्चित करें कि हम कोई भी कोड लिखना शुरू करने से पहले एक known good place पर हैं।

जब हम Android Studio में एक नया प्रोजेक्ट बनाते हैं तो सब कुछ सेट अप करने में कुछ समय लगता है।

अपने एप्लिकेशन को चलाने के लिए, हम menu में dropdown पर जा सकते हैं और अपने ऐप को या तो emulator या physical device पर deploy करना चुन सकते हैं।

तो मैं Pixel 2 API 29 चुनूंगा, जो एक emulator है जिसे मैंने पहले बनाया था, उस green triangle को हिट करके emulator को बूट करूंगा अगर यह पहले से मौजूद नहीं है, और फिर अपने प्रोजेक्ट को build करके इस emulator पर deploy करूंगा।

और आप Android Studio के नीचे status में current progress देखेंगे।

इसमें एक या दो मिनट लग सकते हैं।

लेकिन जब यह हो जाएगा, तो ऐप automatically device पर भेज दिया जाएगा और foreground में आ जाएगा।

तो हमें बस तब तक इंतजार करना है जब तक हम emulator पर कुछ action न देख लें।

Okay, great।

यह promising लग रहा है।

हम "Hello World" टेक्स्ट के साथ Tippie नाम का एक एप्लिकेशन देख रहे हैं, जो empty project के लिए default है।

और इससे हमें confidence मिलता है कि हम basic project को successfully run कर सकते हैं।

आइए Android Studio में आते हैं और starter files के बारे में एक क्विक मिनट बात करते हैं।

और actually, यह काफी simple है क्योंकि केवल दो फाइलें हैं जिनसे हमें concerned होना है – MainActivity.kt और activity_main.xml। आप Android terminology में एक activity को एक screen represent करने के रूप में सोच सकते हैं।

तो हमारे पास अभी जो प्रोजेक्ट है, उसमें केवल एक screen है।

और उसे main activity या main screen कहा जाता है।

और वह business logic है जिसे हम यहां MainActivity नाम की इस फाइल में define कर रहे हैं।

विशेष रूप से, starter code हमें एक function या method देता है जो पहले से ही override किया हुआ है।

और उसे onCreate कहा जाता है – Android system automatically इस function को invoke या call करेगा जब हमारा एप्लिकेशन start हो रहा हो, जब यह हमारी screen create कर रहा हो।

और यहां important line है line 9: setContentView(R.layout.activity_main)।

तो R stands for resources।

तो हम यहां कह रहे हैं कि हमारी screen का content या UI resources में layout फाइल होना चाहिए, जिसे activity_main.xml पर define किया गया है।

और indeed, अगर हम इसकी definition पर jump करें, तो हम देख सकते हैं कि यह directly activity_main.xml पर जाता है।

तो मैं यहां project tool window को minimize कर दूंगा ताकि हमें ज्यादा room मिले।

और attributes pane को भी minimize कर दूंगा।

तो यहां exactly वही है जो हम एप्लिकेशन में देख रहे हैं – just एक blank canvas with HelloWorld।

और विशेष रूप से, अगर आप यहां component tree को देखें, तो यह आपके लिए minimized हो सकता है।

लेकिन आप इसे यहां टैप करके expand कर सकते हैं, हम देख सकते हैं कि parent element एक ConstraintLayout है।

और इसका exactly एक child है जिसे TextView या label कहा जाता है।

और उसका एक attribute है जिसकी value hello world है।

और इसीलिए हम अपने running application में Hello World text देख रहे हैं।

इस वीडियो में, हम अपना सारा समय activity_main.xml में बिताएंगे, क्योंकि अभी हम केवल अपने एप्लिकेशन के लिए UI construct करने से concerned हैं।

और विशेष रूप से, यहां हम कैसे end करना चाहते हैं – हमारे पास screen पर eight components होंगे।

बाईं ओर, हमारे पास चार different TextViews हैं – आप TextView को एक label की तरह सोच सकते हैं, जिसे user द्वारा edit नहीं किया जा सकता।

दाईं ओर, हमारे पास actual components हैं जिन्हें TextView describe कर रहा है।

तो हमारे पास सबसे ऊपर एक EditText है, जो user को bill amount डालने की अनुमति देता है, हमारे पास एक SeekBar है, जो user को tip percentage डालने की अनुमति देता है, और फिर bottom के लिए दो और TextViews हैं टिप और टोटल अमाउंट के लिए।

एक और चीज है जिसे मैं शुरू करने से पहले बताना चाहता हूं – हमारे UI के multiple perspectives हैं, जो हम default द्वारा देख रहे हैं वह design preview है, जो actually आपके emulator या device पर दिखेगा।

लेकिन आप code tab में भी drop down कर सकते हैं, जो actual underlying XML है।

तो आप देख सकते हैं कि हमारे पास ConstraintLayout है और फिर एक child view TextView same as design।

Split का मतलब है आप दोनों को देखते हैं।

और हमारा ज्यादातर समय design preview को देखने में बीतेगा।

और हम क्या कर सकते हैं वह है palette में जाकर अलग-अलग components जैसे TextView या EditText को drag और drop करना जो हम चाहते हैं।

और फिर से, वह code tab में represented होगा।

तो बस ध्यान रखें कि design preview में आप जो भी changes करते हैं और underlying XML के बीच one-to-one correspondence है।

तो अभी के लिए, design पर वापस चलते हैं, जो भी components हमारे पास हैं उन्हें delete कर देते हैं, ताकि हमारे पास single ConstraintLayout हो बिना किसी children के।

Documentation ConstraintLayout को एक ऐसे तरीके के रूप में describe करता है जिससे large और complex layouts को flat view hierarchy के साथ बनाया जा सके।

हम sibling views और parent layouts के बीच relationship को constraints के एक set के माध्यम से describe कर सकते हैं जिन्हें हम define करते हैं।

और यह Android system को हमारे UI को gracefully layout करने की अनुमति देता है across phones या tablets के multiple sizes।

और यहां important बात यह है – no nested view groups।

Android पर, अगर आपके पास बहुत deeply nested view hierarchy है, तो इससे बहुत performance degradation होती है और जिसे हम jank या UI lag कहते हैं।

और इसलिए ConstraintLayout हमें nested view groups के बिना complex views बनाने की अनुमति देता है।

टिप कैलकुलेटर प्रोजेक्ट पर वापस आते हुए, हम यहां screen पर सभी eight views को एक single parent ConstraintLayout में layout करने जा रहे हैं, कोई nested view groups नहीं होंगे, जो कि हम उतना ही अच्छा कर सकते हैं, हमारे parent ConstraintLayout के अंदर कोई RelativeLayout या LinearLayout नहीं।

तो भले ही आपने पहले कभी ConstraintLayout के साथ काम न किया हो, अभी एक moment लें और सोचें कि आप screen पर views को एक दूसरे के relative कैसे position कर सकते हैं, ताकि हम इसे flat view hierarchy में describe कर सकें।

Android Studio में वापस, पहली चीज जो हम करेंगे वह है एक TextView को drag करना जो हमारे screen के top left component को represent करता है, जो base label को represent करने वाला TextView है।

पहली चीज जो मैं जब भी कोई component drag करता हूं वह करता हूं वह है ID को update करना कुछ more meaningful बनाने के लिए।

तो मैं इसे tvBaseLabel कहूंगा और फिर text को "Base" पर update करूंगा।

और आप यहां notice करेंगे कि Android Studio complain कर रहा है कि यह TextView constraints miss कर रहा है।

तो इसके पास केवल design-time positions हैं, यह runtime पर position 0,0 पर jump कर जाएगा, जो screen का top left है, जब तक कि हम constraints add न करें।

और यह ConstraintLayout का पूरा point है – हमें हर component को vertically और horizontally constrain करना होगा।

तो vertically, हम क्या करेंगे – tvBaseLabel के top anchor point को drag करेंगे और उसे screen के top पर drag करेंगे।

और फिर attributes tab में, हम margin specify करेंगे कि हम इसे screen के top से कितना दूर चाहते हैं, और मैं top पर 48 dp कहूंगा।

Similarly, हम left margin specify करना चाहते हैं, तो हम left anchor point को drag करेंगे और उसे parent पर drag करेंगे और इसे screen के left end से 32 dp away specify करेंगे।

तो अब आप देख सकते हैं कि error चला गया, हम अब screen के बाईं ओर के अन्य तीन TextViews के लिए same process करेंगे।

Base label के ठीक नीचे वाले से शुरू करते हैं – tvTipPercentLabel।

Author text here को 24% पर सेट करें।

उसके नीचे वाला TextView होगा tvTipLabel।

Text होगा "Tip"।

और finally हमारे पास tvTotalLabel होगा।

और यहां text होगा "Total"।

तो हमारे पास same issue है जहां हमें इन सभी को horizontally और vertically constrain करना होगा। Vertically, हम क्या करेंगे – प्रत्येक TextView के लिए top anchor point लेंगे और उसे ऊपर वाले component पर drag करेंगे।

और हम 32 dp का margin specify करेंगे जिसका मतलब है कि प्रत्येक TextView को ऊपर वाले TextView से 32 dp नीचे रहना चाहिए – यानी top anchor point को ऊपर वाले TextView के bottom anchor point पर drag करेंगे।

और फिर से same thing – 32 dp से इनमें से प्रत्येक view को vertically constrain करें।

अब horizontally के बारे में क्या – अगर हम desired end state पर वापस जाएं, तो आप notice करेंगे कि अगर हम यहां एक vertical line draw करते हैं, तो बाईं ओर के सभी components, वे सभी उस top TextView यानी tvBaseLabel के right end से aligned होंगे।

यही वह तरीका है जिससे हम उन्हें horizontally constrain करना चाहते हैं।

और हम actually यह Design tab में कर सकते हैं – आप कह सकते हैं align और फिर align right edges।

लेकिन मैं आपको दिखाना चाहता हूं कि यह code tab में कैसे करते हैं।

तो अगर मैं code tab खोलूं, जैसा हमने बात की, Design tab में आप जो भी change करते हैं उसका corresponding change code tab में होता है।

तो अभी हमारे पास चार TextViews हैं और exactly वही हम यहां देख सकते हैं – हमारे पास 1,2,3,4 हैं, जैसा हमने बात की, अभी एक error है कि हम इन्हें horizontally constrain नहीं कर रहे।

इसीलिए हमारे पास यह red underline है।

Vertical constraint वह है जो आप यहां देख सकते हैं।

तो इस line से हम जो communicate कर रहे हैं वह यह है कि tvTipPercentLabel का top exactly tvBaseLabel के bottom के equal होना चाहिए, साथ में 32 dp का margin जिसका मतलब है कि आप इसे ऊपर वाले component से 32 pixels नीचे चाहते हैं।

Similarly, हम क्या करना चाहते हैं वह यह specify करना है कि इस component का end, यानी tvTipPercentLabel का end, tvBaseLabel के end के equal होना चाहिए।

और हम चाहते हैं कि यह बाईं ओर के प्रत्येक component पर apply हो। So with that, आप देख सकते हैं कि error कैसे चला गया।

और अगर हम Design tab पर वापस जाएं, तो आप देख सकते हैं कि कैसे सब कुछ अब aligned है।

एक और चीज जो मैं यहां बताना चाहता हूं वह यह है कि tools namespace केवल design preview को render करने के purpose के लिए उपयोग किया जाता है।

क्योंकि हमने अब इनमें से प्रत्येक view को horizontally और vertically fully constrain कर दिया है, हमें actually इसकी अब जरूरत नहीं है।

तो मैं इनमें से प्रत्येक को select करूंगा और delete कर दूंगा।

और एक और चीज – मैं consistent style और different attribute names के ordering पर pretty big हूं।

तो उदाहरण के लिए, यहां हमारे पास ending angle bracket same line पर है या new line पर।

और इसे automatically हमारे लिए fix करने के लिए, मैं double shift tap करूंगा, और फिर reformat search करूंगा।

और code को reformat करने के लिए एक shortcut है।

अगर मैं ऐसा करता हूं, तो आप देख सकते हैं कि Android Studio ने पूरे file में इसे fix करने में हमारी मदद की, जो मुझे बहुत ज्यादा पसंद है।

Right, तो चलिए Design tab पर वापस चलते हैं।

और screen के दाईं ओर के components पर जाने से पहले, एक चीज जो मैं करना चाहता हूं वह है कुछ quick design tweaks।

पहला, मैं text को यहां थोड़ा बड़ा बनाना चाहता हूं।

तो मैं text appearance को medium बनाऊंगा, आप देख सकते हैं कि इसने इसे बड़ा कर दिया।

और फिर यह tvTipPercentLabel थोड़ा unique है, क्योंकि यह उस value को represent कर रहा है जो user ने actually choose किया है।

तो यह indicate करने के लिए कि यह दूसरों से थोड़ा अलग है, मैं यहां text को bold कर दूंगा।

Cool, मुझे यह पसंद है।

अब चलिए screen के दाईं ओर के चार components के बारे में सोचते हैं।

यह वाला EditText होने वाला है, उसके नीचे SeekBar।

और फिर उसके नीचे दो TextViews।

तो चलिए एक EditText drag करते हैं।

और जो हम drag करेंगे वह है वह वाला जो कहता है number decimal।

और इन सभी different EditTexts के बीच difference actually काफी simple है।

यह simply input type है।

क्योंकि हम currency के साथ deal कर रहे हैं, हम चाहते हैं numbers और decimals हमारे में।

इसके नीचे, हमारे पास एक SeekBar होगी।

और फिर उसके नीचे, हम दो TextView drag करेंगे।

Alright, चलिए यहां IDs को update करते हैं कुछ more sensible बनाने के लिए।

तो यह वाला etBaseAmount कहलाएगा।

Next हमारे पास seekBarTip होगा।

फिर हमारे पास tvTipAmount होगा।

और finally हमारे पास tvTotalAmount होगा।

चलिए यहां text को update करते हैं 103.11 पर।

और यह वाला, मुझे लगता है हमने 1996 कहा था।

चलिए इन elements को position करने से पहले कुछ design tweaks करते हैं।

तो ये bottom TextViews, ये पूरे ऐप का सबसे important part हैं।

तो मैं text को large बनाऊंगा।

SeekBar के लिए, मैं एक hardcoded width 200 dp specify करूंगा ताकि यह थोड़ा wider हो।

और फिर यहां एक attribute है जिसे Max कहते हैं, जो वह maximum amount है जो SeekBar hold करेगा।

और वह 30 होगा।

क्योंकि हम केवल 30% तक allow करते हैं।

EditText के लिए, मैं ems को 8 पर सेट करूंगा, जिसका मतलब है कि यह EditText कितने characters wide होगा और 8 हमारे लिए sufficient है। मैं text size को 24 sp पर increase करूंगा।

और finally, मैं यहां एक hint या placeholder add करूंगा, जो user को बताएगा कि यह EditText किसके लिए है – "Bill Amount"।

अब चलिए सोचते हैं कि इनको कैसे position करना है।

तो vertically, bottom के दो TextViews को vertically aligned होना चाहिए, तो मैं उन दोनों को select करूंगा और फिर align vertical centers करूंगा।

और similarly उनके ऊपर वालों के लिए।

और फिर similarly tip percent और seekbar के लिए।

और आप देख सकते हैं कि Design tab में, हम actually constraints का यह nice preview देख पा रहे हैं जो add किए गए हैं।

Bill amount के लिए।

चलिए सोचते हैं कि इसे horizontally कैसे constrain करना है – यह corresponding TextView से 32 dp दूर होगा जो बाईं ओर है।

और horizontally, दाईं ओर के सभी अन्य components, ये bottom के तीनों, bill amount EditText के left end से aligned होने चाहिए – तो उन सभी को select करूंगा, और मैं specify करूंगा कि left edges सभी aligned होने चाहिए।

यह अच्छा लग रहा है।

एकमात्र चीज जो अब हमें करनी है – अगर हम यहां hover करें, तो हम EditText पर एक vertical constraint miss कर रहे हैं।

तो ऐसा करने के लिए, मैं code tab में जाऊंगा।

यहां है etBaseAmount पर EditText।

और जिस तरह से हम vertical positioning communicate करेंगे वह है इस element के top को top left view के top consider करके जो tvBaseLabel है और similarly इस view का bottom भी tvBaseLabel का bottom होना चाहिए।

तो यह vertically right in the middle होगा।

तो अगर आप Design tab पर वापस जाएं, तो आप देख सकते हैं कि अब errors चले गए हैं।

और आप visually देख सकते हैं कि ये constraints कैसे दिखते हैं।

अगर आप Design tab पर वापस जाएं, फिर से, हमें इस tools namespace की अब जरूरत नहीं है, क्योंकि हम everything को fully constrain कर रहे हैं।

चलिए code को really fast reformat करते हैं।

और फिर एक और चीज जो मैं करना चाहता हूं – भले ही इसकी जरूरत न हो program को चलाने के लिए, just developer information के लिए, मैं इन्हें एक comment के साथ label करना चाहूंगा।

ये बाईं ओर के views हैं।

और फिर चार TextViews के बाद, EditText से शुरू करके, ये दाईं ओर के views हैं।

यह right है यह देखने के लिए कि यह कैसा दिखता है।

Okay, awesome।

जैसा हम expect करते हैं यह pretty much exactly mirror कर रहा है जो हम design preview में देखते हैं।

एकमात्र चीज जो मैं यहां fix करना या improve करना चाहता हूं वह यह है कि यह थोड़ा weird है कि हमारे पास already टिप और टोटल अमाउंट के values हैं, भले ही user ने actually कुछ enter न किया हो।

और यही tools namespace का purpose है जिसके बारे में हमने पहले बात की थी।

तो मैं क्या करूंगा – corresponding TextView को select करूंगा।

और यहां text होने के बजाय, मैं scroll down करूंगा।

मैं इसे wrench text area में move करूंगा।

और वह है tools namespace।

तो मैं इन्हें tools text में move करूंगा।

और finally, same thing यहां over here।

बस आपको दिखाने के लिए कि इसने क्या किया – अगर हम code tab पर वापस जाएं, अगर आप tvTipPercentLabel को देखें, अब instead of having android:text attribute, यह अब tools:text attribute है।

अगर हम ऐप को एक last time run करें, तो देखते हैं कि इसका initial layout पर क्या impact पड़ता है।

Awesome, यह pretty good लग रहा है।

उम्मीद है इस वीडियो ने आपको ConstraintLayout की power का अच्छा sense दिया।

एक चीज जो मैं आपको just demonstrate करने के लिए दिखा सकता हूं कि हमने क्या किया है – इन eight views के साथ screen पर, वे सभी एक single parent में located हैं।

और अगर मैं उस top left TextView को drag करता हूं तो everything उसके according से move करता है, जो कि सभी views को एक दूसरे के relative constrain करने का really nice तरीका है।

तो अगले वीडियो में job actually business logic को MainActivity में hook up करना है, ताकि हम input पर react कर सकें और टिप और टोटल compute कर सकें।

अगले वीडियो में मिलते हैं।


पिछले वीडियो में, हमने अपने टिप कैलकुलेटर एप्लिकेशन के लिए screen पर आठ views layout किए।

इस वीडियो में, हम business logic add करना चाहते हैं ताकि हमारा ऐप interactive बने। हम यह कर पाना चाहते हैं कि जब user SeekBar पर scrub करे, तो हम tip percent label को update करना चाहते हैं।

और जब वे बेस अमाउंट enter करें, तो हम उस value को लेना चाहते हैं और फिर टिप और टोटल अमाउंट compute करना चाहते हैं।

विशेष रूप से, आप notice करेंगे कि यहां कोई Submit button नहीं है।

तो जैसे ही user बेस अमाउंट या टिप पर्सेंटेज बदलता है, हम dynamically टिप और टोटल अमाउंट compute करना चाहते हैं जब भी कुछ बदलता है।

तो first exercise के रूप में, जो मैं कर पाना चाहता हूं वह यह है कि जैसे ही user SeekBar पर value बदलता है, मैं tip percent label को update करके indicate कर पाऊं।

तो ऐसा करने के लिए पहली चीज जो हम करेंगे वह है screen पर उन views का reference लेना जिनसे हमें actually data read करना है या modify करना है।

और actually screen पर पांच different widgets हैं जिनकी हमें परवाह है – tip percent label और फिर दाईं ओर के screen के सभी चार components।

तो Android Studio में, हम इसे यहां ऊपर एक bunch of variables declare करके करेंगे प्रत्येक component के लिए।

उदाहरण के लिए, हमारे पास EditText है, वह होगा etBaseAmount।

और इसका type होगा EditText।

लेकिन syntax के बारे में ज्यादा worry न करें अगर यह confusing है – हम बस इतना कह रहे हैं कि एक private variable।

यह late initialization है क्योंकि हम इसे onCreate method के अंदर initialize करने जा रहे हैं constructor में नहीं, इसीलिए यह late initialization है एक variable और हम इसे etBaseAmount कह रहे हैं। Convention जो मैं follow करता हूं वह यह है कि variable का name exactly ID के name के equal होता है।

तो अब onCreate में।

setContentView के बाद, हम कहेंगे etBaseAmount = findViewById(R.id.etBaseAmount)।

और हम इसे अब screen पर अन्य चार components के लिए repeat करेंगे।

तो हमारे पास seekBarTip है।

और यहां type है SeekBar।

और फिर हमारे पास tvTipPercent है।

वह TextView होने वाला है।

और फिर हमारे पास दो और TextViews हैं।

एक है tvTipAmount, और दूसरा है tvTotalAmount।

अब मैं बस onCreate के अंदर इन सभी के references pull out करूंगा। और finally हमारे पास total amount है।

हमारे objective पर वापस जाते हुए, पहली चीज जो आप करना चाहते हैं वह यह है कि जब user SeekBar पर scrub करता है, तो हम उस user input के changes के notified होना चाहते हैं, और फिर tvTipPercentLabel को update करना चाहते हैं indicate करने के लिए।

तो actually, मुझे यहां variable का name update करने दें just tvTipPercentLabel के लिए consistency के लिए।

और जिस तरह से हम SeekBar पर changes के notified होते हैं वह है उस पर एक listener add करके – यह कहेगा seekBarTip.setOnSeekBarChangeListener।

और अब हमें Android को बताना होगा कि जब SeekBar change हो तो क्या होना चाहिए।

और syntax यहां यह है कि हम कहेंगे object : SeekBar.OnSeekBarChangeListener।

और फिर हम इस class को यहां अंदर define करेंगे।

और Android Studio हमारी मदद करेगा इसे implement करने में – आप उस red underline पर object के under tap करेंगे और implement members पर tap करेंगे।

तीन methods हैं जिन्हें हमें override करना होगा इस interface की definition को comply करने के लिए।

और Android Studio हमारी इसमें मदद करेगा।

और फिर से worry न करें।

फिर से, syntax confusing है।

यहां details यह हैं कि हम एक anonymous class define कर रहे हैं जो इस interface को implement करती है।

तो अगर मैं यहां definition पर जाऊं, तो आप देख सकते हैं कि यह एक public interface है जिसमें exactly वे तीन methods हैं जिन्हें हमने override किया है।

और अब हमारा job है system को बताना कि इनमें से प्रत्येक method के call होने पर क्या होना चाहिए।

और actually, हमें onStartTrackingTouch या onStopTrackingTouch की परवाह नहीं है।

तो मैं यहां दो TODOs को remove कर दूंगा, और इसे empty implementation छोड़ दूंगा।

UI को update करने से पहले, चलिए Android में एक log statement add करते हैं ताकि आसानी से पता चल सके कि क्या हो रहा है।

तो मैं Log.d लिखूंगा और यह एक method है जो दो parameters लेता है।

पहला एक string है, जिसे मैं tag कहूंगा, जिसे मैं बाद में define करूंगा।

और दूसरा भी एक string है, जो एक message या log statement है।

और मैं कहूंगा "onProgressChanged" जो method name है, साथ में progress जो SeekBar का current value है।

तो चलिए इस tag को define करते हैं – मैं class के top पर जा रहा हूं और एक private const val tag define करूंगा।

और convention यहां यह है कि जब भी आपके पास किसी भी तरह का logging हो, tag typically class name होने वाला है।

Alright, चलिए इसे try करते हैं।

तो idea यहां यह है कि हर बार जब SeekBar पर progress change होता है, जिसका मतलब है user scrub कर रहा है, हम logcat में current value print out करेंगे, जो वह जगह है जहां logs output होते हैं।

तो logcat खोलें।

Emulator खोलें।

और जिन logs की हमें परवाह है वे केवल हमारे application से हैं, जो है com.rahul.pandey.tippie और हम केवल info level logs की परवाह करते हैं क्योंकि वही है जो Log.i represent करता है।

हम केवल उन logs की भी परवाह करते हैं जिनका यह particular tag है, जो है MainActivity।

तो चलिए MainActivity को filter के रूप में add करते हैं।

और यहां जैसे ही हम SeekBar बदलते हैं, आप देख सकते हैं कि हमें logcat output की एक line मिलती है, और यह exactly represent करती है कि SeekBar का current indicator क्या दिखा रहा है।

तो अगर हम maximum तक सभी तरह से जाते हैं, तो हम 30 देखते हैं जैसा हम expect करते हैं, और अगर हम सभी तरह से वापस नीचे आते हैं, तो हम zero पर जाते हैं।

तो अब चलिए UI को update करते हैं।

और विशेष रूप से, हम tvTipPercentLabel को update करना चाहते हैं SeekBar के current progress को indicate करने के लिए।

तो हम कहेंगे tvTipPercentLabel.text = "$progress%"।

लेकिन actually, हम progress को string के रूप में represent करना चाहते हैं, int के रूप में नहीं।

और हम उसके बाद एक percent sign concatenate करना चाहते हैं।

तो हम कहेंगे "${progress}%" – यह है कि हम Kotlin में string interpolation कैसे करते हैं।

Similar to जो हमने log statement में किया था, और अंत में percent sign add करें।

चलिए इसे try करते हैं।

तो जैसे ही हम SeekBar पर scrub करते हैं, आप देख सकते हैं कि tvTipPercentLabel SeekBar के current progress के साथ lockstep में update हो जाता है, जो great है।

यहां एक improvement है – initially, हम tip percent में कुछ भी indicate नहीं कर रहे हैं label में।

और इसे fix करने के लिए, चलिए एक और constant define करते हैं, जिसे हम initialTipPercent कहेंगे।

तो हमारे पास private const val initialTipPercent होगा, और हम इसे 15 पर सेट करेंगे।

तो initially, default tip 15% होने जा रही है।

तो listener में कुछ भी करने से पहले constant को define करें।

onCreate method में, हम seekBarTip.progress = initialTipPercent करेंगे।

और हम label को भी appropriately update करना चाहते हैं।

तो हम कहेंगे tvTipPercentLabel.text = "${initialTipPercent}%"।

अब जब हम ऐप चलाते हैं, तो हमें blank tip percent label के बजाय 15% दिखना चाहिए जैसा हम करते हैं और progress bar indicator exactly SeekBar की पूरी width के बीच में है।

अगला, similar to जैसे हम SeekBar में changes पर react कर पा रहे थे, हम EditText में changes पर भी react कर पाना चाहते हैं। तो ET BaseAmount पर एक analogous method है जिसे addTextChangedListener कहते हैं।

और syntax similar है – हम यहां एक object pass करते हैं, जो एक anonymous class है TextWatcher का implementation।

और हम Android Studio की मदद लेंगे once again – तीन methods हैं जिन्हें हमें override करना है।

तो मैं उस red light bulb पर tap करूंगा और implement members करूंगा – तीनों को override करूंगा।

और फिर से before की तरह, केवल एक चीज जिसकी हमें परवाह है वह है afterTextChanged – मैं यहां implementation का body delete कर दूंगा।

बस better understanding के लिए कि यहां क्या हो रहा है।

फिर से, afterTextChanged के बाद एक log statement add करते हैं।

Log.d(TAG, "afterTextChanged: $s")।

Alright, चलिए इसे try करते हैं।

तो $s वह parameter है जो pass in होता है।

And वह actually वही है जो user उस moment type कर रहा है।

इसे run करते हैं, चलिए logcat एक बार फिर खोलते हैं।

Alright, तो जैसे पहले, अगर मैं SeekBar modify करता हूं, तो आप देख सकते हैं कि यह appropriately बदल रहा है।

और फिर अगर मैं EditText में value add करता हूं, तो आप देख सकते हैं 800 – यह log में appropriately update हो रहा है।

दो quick notes।

पहला, मैं sometimes देखता हूं कि students trip up हो जाते हैं जब वे Kotlin में functions invoke करते हैं।

जो MSG आप देख रहे हैं जब हम Log.d call करते हैं वह Android Studio का एक hint है कि वह parameter क्या represent करता है।

तो अगर आप actually MSG type करते हैं, तो वह compile error की ओर ले जाएगा।

तो सुनिश्चित करें कि आप ऐसा न करें।

दूसरा, मैं demystify करना चाहता हूं कि object keyword का क्या मतलब है।

तो object expressions जैसे हम अब तक दो बार use कर चुके हैं, ये examples हैं कि anonymous classes कैसे create करते हैं, जो one-time use classes हैं जिनका commonly interfaces implement करने के लिए उपयोग किया जाता है।

तो हमारे पास TextWatcher और OnSeekBarChangeListener दोनों हैं जो Android system द्वारा defined interfaces हैं।

और ये methods जो हम override कर रहे हैं, वे automatically हमारे लिए invoke होंगे जब user underlying EditText या SeekBar पर appropriate action लेता है।

तो अब हमारे पास सारे ingredients हैं actually इस ऐप को functional बनाने के लिए।

जब भी EditText बदलता है, मैं computeTipAndTotal नाम का एक method call करने जा रहा हूं।

और यह actually वही है जो EditText और SeekBar से values लेगा और फिर tip और total amount को appropriately update करेगा।

तो यह method अभी exist नहीं करता।

लेकिन फिर से, चलिए Android Studio की utility का leverage लेते हैं और इसे हमारे लिए MainActivity के अंदर create करवाते हैं।

और इस method में कुछ चीजें होनी हैं।

पहला, हम बेसिक और टिप पर्सेंट का value लेना चाहते हैं।

दूसरा, हम टिप और टोटल compute करना चाहते हैं।

और तीसरा, हमें UI को update करना है उन values को दिखाने के लिए।

तो बेसिक और टिप का value लेने के लिए, यह pretty straightforward है – हम just EditText etBaseAmount को देखते हैं, text grab करते हैं, और उस पर toString() call करते हैं।

और फिर एक string पर, हम जानते हैं कि यह currency जैसा decimal होने वाला है, तो हम उस पर toDouble() call करेंगे ताकि इसे एक number में बदल सकें जिसके साथ हम work कर सकें।

और हम इसे baseAmount कहेंगे।

और फिर similarly, टिप पर्सेंट के लिए, हम SeekBar पर progress attribute का value लेना चाहते हैं, यह attribute progress कहलाता है, और वह एक variable में save होगा जिसे मैं tipPercent कहूंगा।

Next, हम टिप और टोटल अमाउंट compute करना चाहते हैं।

तो टिप अमाउंट होगा baseAmount * tipPercent / 100।

उदाहरण के लिए, अगर बेस अमाउंट $100 है, मैं $100 का meal खाया, और टिप पर्सेंट 20 है, तो मैं expect करता हूं टिप अमाउंट $20 हो।

तो वह 20/100 = 20% * 100 होगा।

और वह मुझे $20 देगा।

तो वह होगा tipAmount।

और फिर हमारे पास totalAmount है, और totalAmount simply baseAmount + tipAmount होने वाला है।

Okay, finally, हमें UI को update करना है।

और फिर से, यह pretty straightforward निकलता है, क्योंकि हमारे पास उन दो TextViews का reference है जो टिप और टोटल अमाउंट दिखाते हैं – tvTipAmount और tvTotalAmount।

तो हम tvTipAmount.text = tipAmount.toString() करेंगे।

और यह error throw करेगा क्योंकि tipAmount एक number है, यह एक double है, लेकिन हम actually एक CharSequence require करते हैं।

और इसे CharSequence देने के लिए, हम बस इस पर toString() call कर सकते हैं।

और फिर similarly, हमें tvTotalAmount.text = totalAmount.toString() कहना होगा।

And यह plus sign होना चाहिए।

Wait, यह हमारे application का पूरा brain है।

तो अगर हम इसे run करते हैं, तो हम क्या कर रहे हैं – anytime EditText value change होता है, हम इस method को call करने जा रहे हैं और हमें UI को update करना चाहिए correct amount के साथ टिप और टोटल अमाउंट के लिए। Right, तो हमारे पास 15% टिप के लिए है।

अगर मैं यहां $100 add करता हूं, तो आप immediately देखते हैं कि हमें correct टिप और टोटल computation मिलती है।

और हम वही logic चाहते हैं execute हो अगर मैं SeekBar बदलता हूं, टिप पर्सेंट।

और यह turns out really easy है, क्योंकि हमने सारा logic इस method में abstract कर दिया है।

तो मैं computeTipAndTotal को यहीं onProgressChanged में call करने जा रहा हूं।

Alright, तो अगर आप इसे अब try करते हैं, तो हमारे पास एक pretty functional ऐप होना चाहिए।

तो before की तरह, अगर मैं यहां 100 डालता हूं।

यहां, हम correctly 115 compute करते हैं।

और अगर मैं percent बदलता हूं, तो आप देख सकते हैं यह appropriately update करता है।

Alright, तो यह actually pretty well काम कर रहा है।

लेकिन दो चीजें हैं जो मुझे लगता है कि incorrect हैं या improved की जा सकती हैं।

बस एक moment अभी लें और सोचें कि क्या दो improvements हैं जो आप अभी के ऐप में कर सकते हैं – try playing around with it, देखें कि क्या आप किसी issues को identify कर सकते हैं।

Okay, तो पहला improvement जो हम कर सकते हैं वह actually एक bug है।

तो notice करें अब क्या होगा अगर मैं बेस अमाउंट पर backspace करता हूं, ताकि वहां कुछ न रहे – तो आप देख सकते हैं ऐप actually crash हो गया।

तो अगर हम logcat देखें, तो देखते हैं कि actually error क्या था।

तो मैं stack trace के बहुत top तक scroll up करने जा रहा हूं।

और आप यहां देख सकते हैं हमारे पास एक NumberFormatException है।

यह important part है – there's an empty string।

And stack trace हमें exactly बताता है कि issue कहां हुआ – MainActivity line 58।

और जो issue हो रहा है वह यह है कि जब EditText का empty value होता है, तो empty string को double में convert करने की कोशिश करना sense नहीं बनाता।

The very first thing जो हमें यहां करना चाहिए वह है actually check करना अगर etBaseAmount.text empty है, तो हमें early return करना चाहिए।

Additionally, हमें tvTipAmount और tvTotalAmount के values को clear करना चाहिए।

क्योंकि अगर EditText empty है, तो इसका मतलब है tap करने के लिए कुछ नहीं है।

और हमें उन दो TextViews के लिए कुछ नहीं दिखाना चाहिए, फिर हम return call करते हैं, ताकि function का बाकी हिस्सा execute न हो।

दूसरा improvement जो हम करेंगे वह है formatting के बारे में टिप और टोटल अमाउंट के output का।

तो यह noticeable नहीं है जब हम बेस अमाउंट के लिए 100 enter करते हैं।

लेकिन अगर हम 100.9 add करते हैं, तो आप देख सकते हैं टोटल अमाउंट बहुत long और unwieldy हो जाता है।

क्योंकि हम currency के साथ deal कर रहे हैं, हमें really mandate करना चाहिए कि टिप और टोटल अमाउंट दोनों में exactly दो decimal points हों।

और हम ऐसा करेंगे यहीं – instead of just toString() call करने के, हम string को format करना चाहते हैं इससे पहले कि हम इसे TextView में डालें।

तो हम ऐसा करते हैं इस format method का उपयोग करके।

तो हम format को ऐसे define करते हैं "%.2f".format(tipAmount) – जिसका मतलब है हम decimal point के बाद केवल दो numbers चाहते हैं।

और फिर similarly टोटल अमाउंट के लिए "%.2f".format(totalAmount)।

चलिए इसे try करते हैं।

उम्मीद है अब, इस scenario में, हमें actually 116.04 के साथ end होना चाहिए instead of यह बहुत long decimal जो हुआ था।

100 right away डालते हैं – आप देख सकते हैं instead of केवल एक decimal point के, अब हमारे पास दो हैं।

और true test तब है जब मैं 100.9 type करता हूं।

अब, इसका display way better है, हमारे पास 116.04 है rather than वह huge decimal जो unreadable हो जाता था।

तो इस point पर, हमारे पास एक बहुत functional ऐप है। हमने क्या किया है – layout पर relevant views के references लिए, और फिर SeekBar और EditText पर listeners add किए क्योंकि कोई Submit button नहीं है।

Anytime SeekBar या EditText में कोई change होता है, हम dynamically टिप और टोटल अमाउंट compute कर रहे हैं और views को appropriately update कर रहे हैं इस computeTipAndTotal method में।

तो अगले वीडियो में, मैं आपको कुछ style improvements के साथ-साथ इसे personalize करने का तरीका और एक really cool animation दिखाना चाहता हूं।

तो अगले वीडियो में मिलते हैं।


इस point पर, हम अपने टिप कैलकुलेटर के implementation के साथ done हैं।

इस वीडियो में, हमारा goal ऐप में कुछ color animation और personalization add करना है।

तो हम footer से शुरू करेंगे bottom में।

बहुत सारे apps या websites में यह होता है जहां लिखा होता है "Made with love in California" या "Made with love by this person"।

तो हम screen के bottom में एक text add करके शुरू करेंगे।

तो चलिए Android Studio में जाते हैं, activity_main.xml खोलते हैं और bottom तक scroll down करते हैं और हम यहां एक TextView drag करने जा रहे हैं।

इसे tvFooter का ID देते हैं।

और फिर text होगा "Made with love by Rahul" और जाहिर है आप इसे however चाहें personalize कर सकते हैं। इसे constrain करने के लिए।

हम इसे horizontally screen के center में रखने जा रहे हैं।

तो हम left और right constraint add करेंगे इसे centered बनाने के लिए, और फिर हम इसे screen के bottom से 32 dp दूर रखेंगे।

मैं यहां कुछ different style tweaks भी add करना चाहता हूं।

पहला है all caps – मैं यहां सब कुछ capitalized बनाना चाहता हूं।

और मैं font को sans-serif-condensed-light पर बदलना चाहता हूं।

और फिर finally, मैं इसे थोड़ा larger बनाना चाहता हूं – text appearance, medium weight।

और finally, मैं "love" word को emoji से replace करना चाहता हूं।

और आप इसे या तो अपने keyboard में add कर सकते हैं, या दूसरा तरीका यह है कि अगर आप "heart emoji" के लिए Google करते हैं, तो first result जो आता है, मुझे यहां option देता है emoji को copy और paste करने का।

इसे paste करें।

और यह preview में थोड़ा weird लगता है, लेकिन जब आप इसे design में render करते हैं तो यह properly दिखता है।

और अगर हम इसे ऐप में check करते हैं।

Awesome, यह pretty good लग रहा है।

अगली चीज जो मैं करना पसंद करता हूं वह है color scheme को change करना।

ताकि हम इन default status bar color, color primary, और background white से away move करें।

तो मुझे explain करने दें कि ये colors कहां से आ रहे हैं।

एक बहुत important file है जो हर single Android app में exist करनी चाहिए।

और उसे AndroidManifest.xml कहते हैं।

तो अगर हम उसे खोलते हैं, तो यह फाइल आपके application के सभी different components को describe करती है, permissions, उदाहरण के लिए, अगर आपके ऐप को internet permission चाहिए, और बहुत कुछ।

और हमारे लिए important line यहीं line 11 पर है, जहां हम अपने application के theme को describe कर रहे हैं, और यह एक फाइल है जो automatically हमारे लिए create हो जाती है जब हम empty project बनाते हैं।

तो मैं यहां definition पर jump करने जा रहा हूं।

और आप देखेंगे यहां दो different files हैं – एक normal theme के लिए और एक night theme के लिए।

और जो हम currently देख रहे हैं वह normal है, मैं उसे खोलूंगा।

और यह वह जगह है जहां हमें default application के colors मिल रहे हैं जो हमारे पास हैं।

तो colors को update करने के लिए, हमें new colors define करने होंगे और फिर उन्हें यहां replace करना होगा। हम एक नजर डाल सकते हैं कि यह फाइल कहां रहती है इस option को hit करके, select open file, और हम देख सकते हैं कि यह resources, values, और themes directory के अंदर रहती है।

और colors भी colors.xml में values directory के अंदर defined हैं।

और प्रत्येक color को hexadecimal value के रूप में define किया गया है – purple_500, और so on।

तो हमारा job है – चलिए figure out करते हैं कि हमें कौन से colors चाहिए, और फिर उन्हें यहां add करते हैं।

और फिर हम उन्हें themes.xml फाइल के अंदर reference करेंगे।

तो यह figure out करने के लिए कि हमें कौन से colors चाहिए, एक couple different options हैं – मैं आपको दिखाऊंगा जो मैं typically करता हूं अगर आप color.adobe.com पर जाते हैं।

यहां एक really nice tool है जहां आप figure out करते हैं कि आपको किस तरह का color scheme चाहिए।

तो यहां एक couple different options हैं – आप color harmony rule pick कर सकते हैं, analogous, monochromatic, triad, और so on।

एक बार आप किसी चीज से खुश हो जाते हैं, तो आप scroll down कर सकते हैं और यहां से hexadecimal values grab कर सकते हैं।

तो मैंने यह exercise already किया था।

और यहां वे colors हैं जो मैंने निकाले – मेरे पास एक है जिसे primary blue कहूंगा, darker blue और background blue।

तो चलिए colors.xml में जाते हैं और इन्हें define करते हैं – पहला वाला primaryBlue कहलाएगा और इसकी यह value है।

Next वाला backgroundBlue, या next वाला darkerBlue।

और finally, हमारे पास backgroundBlue है।

तो अब themes.xml में, मैंने colorPrimary को primaryBlue पर update किया।

और फिर मैंने primaryVariant को darkerBlue पर update किया, और वह status bar का color होने वाला है।

और फिर finally, पूरे ऐप पर background color रखने के लिए, मैं यहां एक और attribute add करने जा रहा हूं, जिसे android:colorBackground कहते हैं।

और वह backgroundBlue होने वाला है जो हमारे पास है।

चलिए इसे try करते हैं।

Awesome, यह great लग रहा है।

तो हम अब desired end state के बहुत close हैं – हमारे पास footer है, और हमारे पास customized color है।

आखिरी चीज जिसके बारे में मैं बात करना चाहता हूं वह है टिप description पर यह animation।

और यहां actually यह कैसा दिखता है।

जैसे ही user scrub कर रहा है, हम dynamically उस word का color update करेंगे जिसका उपयोग current tip percentage को describe करने के लिए किया जाता है, और यह red से जाएगा अगर यह बहुत bad tip है एक really bright green तक अगर यह really good tip है।

न केवल इतना, बल्कि हम उस word या adjective को भी change करने जा रहे हैं जिसका उपयोग tip percentage को describe करने के लिए किया जाता है।

तो यह user को really nice interactive feedback देता है कि वे किस तरह की tip छोड़ रहे हैं।

Alright, तो पहली चीज जो हम करेंगे वह है just एक TextView add करना SeekBar के नीचे और इन दो TextViews के बीच vertical distance increase करना।

तो इन other editor windows को close कर दें क्योंकि हमें उन्हें फिर से देखने की जरूरत नहीं है।

Activity_main में।

हम क्या करेंगे – पहले tipPercentLabel जो 24% है और tvTipLabel के बीच distance increase करें।

चलिए margin को यहां 56 dp पर increase करते हैं।

Next, चलिए एक और TextView drag करते हैं।

और हम इसे tvTipDescription कहेंगे।

और फिर text empty होना चाहिए, क्योंकि वह initial tip percent पर depend करेगा, जिसे programmatically set किया जाता है।

लेकिन इसका better sense पाने के लिए कि यह कैसा दिख सकता है, हम tools namespace का उपयोग करने जा रहे हैं और यहां "Acceptable" कहेंगे।

यह अच्छा लग रहा है।

और अब हमें इसे horizontally और vertically position करना होगा।

तो vertically, यह seekBarTip के ठीक नीचे होने वाला है, और हम यहां margin add करेंगे maybe 8 dp।

और फिर हम चाहते हैं कि ये दो horizontally aligned हों।

तो horizontal centers, great।

और आप देख सकते हैं कि इसने left और right constraints कैसे add किए।

तो यह right in the middle होगा।

और आप देख सकते हैं कि error भी चला गया।

तो अब MainActivity में वापस, हमें उस TextView का reference लेना होगा।

तो चलिए कहते हैं ID यहां tvTipDescription था।

तो जब मैं tvTipDescription कहूंगा, यहां उसका reference लूंगा।

और हर बार जब SeekBar बदलता है, वहीं हमारे पास अब potential है उस text पर language को update करने का।

तो एक और method यहां चाहते हैं जिसे updateTipDescription कहेंगे।

और चलिए Android Studio की मदद लेते हैं इसे create करने के लिए क्योंकि यह method अभी exist नहीं करता।

और एक चीज जो हम actually करेंगे वह है updateTipDescription method में एक parameter के रूप में, मैं progress pass करना चाहूंगा – progress।

और फिर से, Android Studio अब हमारी मदद कर सकता है इसे उस function में parameter के रूप में add करने के लिए जिसे हमने define किया है।

उस red light bulb पर tap करें, और Android Studio को parameter add करने में मदद करने दें। और मैंने यहां बस एक parameter add किया।

और instead of calling it progress, मैं इसे tipPercent कहूंगा।

और यह Int type का है।

तो अब idea यह है कि tipPercent के value के आधार पर, हम tvTipDescription.text को set कर पाना चाहते हैं something like "Good"।

And of course, यह "Good" value के आधार पर बदल जाएगा।

Kotlin में construct यह decide करने के लिए कि किसी चीज का value क्या होना चाहिए based on a set of conditionals उसे when कहते हैं जो Java में switch के similar है।

तो मैं कहूंगा val tipDescription = when और फिर tipPercent के value के आधार पर certain action लेंगे।

तो अगर tipPercent 0 और 9 के बीच है, तो string "Poor" होनी चाहिए।

अगर यह 10 और 14 के बीच है, तो हम इसे "Acceptable" कहेंगे। 15 और 19 के लिए, यह "Good" होगा।

और जब यह 20 और 24 के बीच हो।

यह "Great" होगा।

और यहां एक extra period होना चाहिए।

और finally, anything else मतलब value 24 से ऊपर है तो हम "Amazing" कहेंगे।

और so now instead of using "Good" यहां, हम tipDescription कहेंगे।

और finally इससे पहले कि हम इसे test करें, एक और चीज जो मैं करना चाहता हूं – very beginning में, जब हम अपना screen set up कर रहे होते हैं, जो कि onCreate method में है, जैसे ही हमें प्रत्येक view का reference मिल जाता है, हम updateTipDescription को यहीं call करना चाहेंगे initialTipPercent के साथ just ताकि language हमेशा in sync रहे जो हम start out करते हैं।

चलिए इसे try करते हैं।

तो अब hopefully हमें एक TextView देखना चाहिए SeekBar के ठीक नीचे और उस TextView पर text बदलना चाहिए according to जो हमने SeekBar के माध्यम से select किया है।

Okay, यह already promising लग रहा है क्योंकि initially tipPercent 15 है, जिसका मतलब है हम when statement के इस branch में fall करते हैं और इसका मतलब है value "Good" होनी चाहिए।

वह Good है।

और फिर अगर हम इसे zero तक नीचे लाते हैं, तो हमें "Poor" मिलता है और अगर हम सभी तरह से ऊपर जाते हैं, तो हमें "Amazing" मिलना चाहिए जो हमें मिलता है।

एक quick चीज जो करना चाहता हूं – वापस activity_main में।

मैं इसका font weight bold पर सेट करना चाहता हूं।

TextStyle bold होना चाहिए ताकि यह थोड़ा ज्यादा stand out करे।

Finally, आखिरी चीज जो मैं दिखाना चाहता हूं वह है यह interactive color animation जहां अगर user बहुत good tip pick करता है तो हम bright green दिखाते हैं और अगर user bad tip pick करता है, तो हम red color दिखाते हैं indicating something went wrong।

Android Studio में वापस आते हुए MainActivity.kt में updateTipDescription वह जगह है जहां हम tipPercent के आधार पर color update करने का logic add करने जा रहे हैं।

सवाल यह है कि हम integer के आधार पर dynamically color कैसे compute करते हैं – हम इसे interpolation नामक एक concept के through करेंगे, जो actually एक fancy word है किसी ऐसी चीज के लिए जो conceptually काफी simple है।

अगर मैं आपसे कहूं कि मैं 100 miles दौड़ रहा हूं, और मैं 75% done हूं, तो आप मुझे बताएंगे कि मैं roughly 75 mile mark पर हूं।

और जो आप अपने head में कर रहे हैं वह है linear interpolation – आप assume कर रहे हैं कि मैं constant speed पर जा रहा हूं starting at zero ending at 100।

इसलिए, मैं 75 miles पर हूं – same thing exactly यहां apply हो रही है।

हर color को integer के रूप में represent किया जा सकता है।

तो अगर मैं 20% tip दे रहा हूं, तो हम two-thirds of the way हैं बहुत worst color और बहुत best color के बीच, जो दो integers हैं।

और हमें बस कुछ simple math करना है exactly उस color value को compute करने के लिए tip description के लिए।

पहली चीज जो हम करेंगे वह है worst और best tip के लिए color define करना।

तो colors.xml खोलें, और चलिए colorWorstTip, colorBestTip add करें और मैंने red और green color pick किए जैसे हमने बात की – हम इन values को paste करेंगे colorWorst और colorBest के लिए।

तो हमारे पास ये defined हैं।

और अब हमारा job simply कुछ math करना है – zero पर, हमें worst tip दिखाना चाहिए, 30 पर, हमें best tip दिखाना चाहिए, और बाकी सब कुछ बीच में कुछ value है।

और यह इतना common निकलता है कि Android actually के पास ArgbEvaluator नाम की कोई चीज है जो इसमें help करती है, जहां हम colors को integer values के रूप में represent करते हैं।

A stands for alpha, RGB है red, green, blue, और यह हमारे लिए color compute करने में help करेगा।

तो MainActivity में वापस आते हुए, हम एक color define करने जा रहे हैं।

And वह ArgbEvaluator().evaluate से आएगा।

और यह तीन parameters लेता है।

एक है fraction – हम इस progress bar पर zero और 30 के बीच कहां हैं। Second है start value, जो बहुत worst color है और end value best color है।

तो fraction simply tipPercent होगा जो parameter pass in है divided by maximum amount of tip जो 30 है।

और वह होगा seekBarTip.max।

Next, हमें बहुत worst color लेना होगा।

और हम ऐसा करेंगे ContextCompat.getColor पास करके this (जो context को refer कर रहा है) और फिर actual color जो हमने colors.xml में just define किया, जो है colorWorstTip।

और finally, हम best color यहां provide करने जा रहे हैं।

एक issue जो आप notice करेंगे वह है type mismatch – हमें float require है, लेकिन हमें integer मिला।

तो by default, क्योंकि numerator और denominator दोनों integers हैं, हम truncation करने जा रहे हैं, जो हम नहीं चाहते।

इसे handle करने का तरीका है numerator या denominator में से एक को float value में cast करना।

And वह इसे resolve कर देगा।

तो अब हमारे पास यह color है, हमें बस tipDescription TextView पर color set करना है – setTextColor(color)।

And finally इससे पहले कि हम इसे try करें, हमें evaluate function call के result को integer में cast करने की जरूरत है, क्योंकि हम जानते हैं कि जिन values के बीच हम compute कर रहे हैं वे integers हैं, तो color int होना चाहिए।

और अब हमें इसे compile और run कर पाना चाहिए just fine।

तो दो चीजें अब होनी चाहिए।

एक है हमें text को bold करना चाहिए।

और दूसरा, तुरंत एक color applied होना चाहिए।

And based on जो percent हम pick करते हैं, उसे adapt करना चाहिए as well।

Right, यह अच्छा लग रहा है।

तो initially, हमारे पास green और red के बीच में right in the middle एक color है।

और अगर मैं सभी तरह से zero तक नीचे जाता हूं, तो आप देख सकते हैं यह कैसे red में बदल जाता है।

और अगर मैं upward scrub करता हूं best tip तक जो 30 है, तो आप देख सकते हैं यह कैसे slowly red से green में transform होता है।

मुझे यह बहुत पसंद है just क्योंकि यह पहले के मुकाबले much more interactive और dynamic feel करता है।

Alright, तो चलिए इसे एक last try देते हैं।

हम बिल के लिए यहां $9 डालने जा रहे हैं।

And फिर जैसे ही मैं scrub करता हूं, आप देख सकते हैं कैसे everything appropriately update होता है।

अगर मैं backspace करता हूं, तो कोई crash नहीं होता, मैं another amount enter कर सकता हूं।

और सब कुछ वैसे ही काम करता है जैसा हम expect करते हैं।

Awesome।

तो अगर यह आपका पहला कभी Android ऐप है, तो यह amazing है।

Congratulations।

मुझे comment में बताएं।

The reason मुझे टिप कैलकुलेटर really पसंद है – इस basic project को extend करने के बहुत सारे ways हैं इसे more interesting बनाने के लिए।

तो एक couple ideas जो मेरे पास थीं – number one, आप bill को n people द्वारा split कर सकते हैं।

तो आप imagine कर सकते हैं कि आप कुछ लोगों के साथ dinner के लिए जाते हैं, आप तीन या चार add करते हैं और फिर आपको उस total amount को तीन या चार से divide करना चाहिए ताकि everyone के लिए एक certain amount pay करना easy हो जाए।

दूसरा, आप एक button या कुछ sort का component add कर सकते हैं जो user को final amount को up या down round करने की अनुमति देता है।

ताकि change deal करने की जरूरत न पड़े।

और of course, design या color updates के terms में बहुत कुछ और है जो आप कर सकते हैं।

तो जो मैं अब recommend करता हूं वह है – किसी भी number of extensions complete करें, जो हमने बात की या जो आप खुद लेकर आए, और फिर आप more या less exactly वही publish कर सकते हैं जो आपके पास Play Store पर है।

मैं यहां उसके through walk नहीं करूंगा, लेकिन मैं description में एक video छोड़ दूंगा जहां मैं उसके बारे में बात करता हूं कि कैसे करना है और मुझे उम्मीद है कि आप इस टिप कैलकुलेटर को अपने Android developer के रूप में journey में starting point के रूप में use करेंगे और future में कई और apps बनाएंगे।

अगर आपको यह पसंद आया, तो please like और comment drop करें।

हम आपसे सुनना पसंद करेंगे।

देखने के लिए बहुत बहुत धन्यवाद और मैं आपको अगले में मिलूंगा।

Bye

  1. एंड्रॉइड के लिए 10 बेस्ट फोटो एडिटर्स: फोटोशॉप के प्रोफेशनल विकल्प एंड्रॉइड के लिए 10 बेस्ट फोटो एडिटर्स: फोटोशॉप के प्रोफेशनल विकल्प

    डिजिटल क्रांति के इस दौर में स्मार्टफोन्स का राज है। वे सिर्फ परिवार-दोस्तों से बात करने के गैजेट से आगे बढ़कर उन कई डिवाइसेज की जगह ले चुके हैं जो कभी अनिवार्य हुआ करते थे। उनमें से एक है कैमरा। आजकल स्मार्टफोन्स के कैमरे इतने एडवांस हैं कि कमाल की क्वालिटी की फोटोज खींचते हैं। यहां तक कह सकता हूं

  1. टॉप 14 एंड्रॉइड कॉल रिकॉर्डिंग ऐप्स - भरोसेमंद, आसान और मुफ्त टॉप 14 एंड्रॉइड कॉल रिकॉर्डिंग ऐप्स - भरोसेमंद, आसान और मुफ्त

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

  1. Android के लिए Showbox: मूवी स्ट्रीमिंग ऐप को सुरक्षित रूप से इंस्टॉल और उपयोग कैसे करें Android के लिए Showbox: मूवी स्ट्रीमिंग ऐप को सुरक्षित रूप से इंस्टॉल और उपयोग कैसे करें

    Android के लिए Showbox ऐप क्या है? Android के लिए Showbox एक ऐप है जो उपयोगकर्ताओं को Android स्मार्टफोन पर फिल्में और टीवी शो स्ट्रीम और डाउनलोड करने की अनुमति देता है। Showbox मूवी ऐप Google Play Store पर उपलब्ध नहीं है लेकिन Showbox apk को एक थर्ड-पार्टी वेबसाइट से डाउनलोड किया जा सकता है जो सुर