कस्टम व्यू कॉम्पोनेंट बनाना

Compose को आज़माएं

Jetpack Compose, Android के लिए यूज़र इंटरफ़ेस (यूआई) टूलकिट है. इसे इस्तेमाल करने का सुझाव दिया जाता है. Compose में लेआउट के साथ काम करने का तरीका जानें.

Compose में पसंद के मुताबिक बनाए गए लेआउट →

Android, यूज़र इंटरफ़ेस (यूआई) बनाने के लिए, कॉम्पोनेंट पर आधारित एक बेहतर और दमदार मॉडल उपलब्ध कराता है. यह मॉडल, बुनियादी लेआउट क्लास View और ViewGroup पर आधारित है. इस प्लैटफ़ॉर्म में, पहले से बनी कई View और ViewGroup सब-क्लास शामिल हैं. इन्हें क्रमशः विजेट और लेआउट कहा जाता है. इनका इस्तेमाल करके, यूज़र इंटरफ़ेस (यूआई) बनाया जा सकता है.

उपलब्ध विजेट की आंशिक सूची में, Button, TextView, EditText, ListView, CheckBox, RadioButton, Gallery, Spinner शामिल हैं. इसके अलावा, खास मकसद के लिए इस्तेमाल किए जाने वाले AutoCompleteTextView, ImageSwitcher, और TextSwitcher भी शामिल हैं.

उपलब्ध लेआउट में, LinearLayout, FrameLayout, RelativeLayout वगैरह शामिल हैं. ज़्यादा उदाहरणों के लिए, सामान्य लेआउट देखें.

अगर पहले से बने विजेट या लेआउट में से कोई भी आपकी ज़रूरतों के मुताबिक नहीं है, तो View की अपनी सब-क्लास बनाई जा सकती है. अगर आपको किसी मौजूदा विजेट या लेआउट में सिर्फ़ मामूली बदलाव करने हैं, तो विजेट या लेआउट की सब-क्लास बनाई जा सकती है और उसके तरीकों को बदला जा सकता है.

View की अपनी सब-क्लास बनाने से, स्क्रीन के किसी एलिमेंट के दिखने के तरीके और उसके फ़ंक्शन पर सटीक कंट्रोल मिलता है. कस्टम व्यू से मिलने वाले कंट्रोल के बारे में बताने के लिए, यहां कुछ उदाहरण दिए गए हैं कि इनकी मदद से क्या-क्या किया जा सकता है:

• पूरी तरह से कस्टम-रेंडर किया गया View टाइप बनाया जा सकता है. उदाहरण के लिए, 2D ग्राफ़िक्स का इस्तेमाल करके रेंडर किया गया "वॉल्यूम कंट्रोल" नॉब, जो एनालॉग इलेक्ट्रॉनिक कंट्रोल जैसा दिखता है.
• View कॉम्पोनेंट के ग्रुप को एक नए कॉम्पोनेंट में जोड़ा जा सकता है. ऐसा शायद कॉम्बो बॉक्स (पॉप-अप सूची और फ़्री एंट्री टेक्स्ट फ़ील्ड का कॉम्बिनेशन), डुअल-पैन सिलेक्टर कंट्रोल (बाएं और दाएं पैन में से हर एक में एक सूची. इसमें यह तय किया जा सकता है कि कौनसे आइटम किस सूची में शामिल होंगे) वगैरह बनाने के लिए किया जा सकता है.
• EditText कॉम्पोनेंट को स्क्रीन पर रेंडर करने के तरीके को बदला जा सकता है. NotePad के सैंपल ऐप्लिकेशन में, लाइन वाले नोटपैड का पेज बनाने के लिए इसका इस्तेमाल किया गया है.
• अन्य इवेंट कैप्चर किए जा सकते हैं. जैसे, की प्रेस. साथ ही, उन्हें कस्टम तरीके से हैंडल किया जा सकता है. जैसे, किसी गेम के लिए.

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

बुनियादी तरीका

View कॉम्पोनेंट बनाने के लिए, यहां ज़रूरी जानकारी दी गई है:

1. किसी मौजूदा View क्लास या सब-क्लास को अपनी क्लास के साथ एक्सटेंड करें.
2. सुपरक्लास के कुछ तरीकों को बदलें. सुपरक्लास के जिन तरीकों को बदला जाना है वे on से शुरू होते हैं. जैसे, onDraw(), onMeasure(), और onKeyDown(). यह on इवेंट जैसा है. इन्हें लाइफ़साइकल और अन्य फ़ंक्शनैलिटी हुक के लिए बदला जाता है.ActivityListActivity
3. अपनी नई एक्सटेंशन क्लास का इस्तेमाल करें. एक्सटेंशन क्लास बनाने के बाद, उसका इस्तेमाल उस व्यू की जगह किया जा सकता है जिस पर वह आधारित है.

पूरी तरह से पसंद के मुताबिक बनाए गए कॉम्पोनेंट

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

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

पूरी तरह से पसंद के मुताबिक बनाया गया कॉम्पोनेंट बनाने के लिए, इन बातों का ध्यान रखें:

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

onDraw() और onMeasure() को एक्सटेंड करना

onDraw() तरीका, Canvas उपलब्ध कराता है. इस पर अपनी पसंद के मुताबिक कुछ भी लागू किया जा सकता है: 2D ग्राफ़िक्स, अन्य स्टैंडर्ड या कस्टम कॉम्पोनेंट, स्टाइल वाला टेक्स्ट या कुछ और.

onMeasure() थोड़ा ज़्यादा जटिल है. onMeasure() , आपके कॉम्पोनेंट और उसके कंटेनर के बीच रेंडरिंग कॉन्ट्रैक्ट का एक अहम हिस्सा है. इसमें शामिल हिस्सों के मेज़रमेंट की जानकारी, सही और असरदार तरीके से देने के लिए, onMeasure() को बदलना ज़रूरी है. पैरंट की ओर से तय की गई सीमा की ज़रूरी शर्तों की वजह से, यह थोड़ा ज़्यादा जटिल हो जाता है. ये ज़रूरी शर्तें, onMeasure() तरीके में पास की जाती हैं. साथ ही, मेज़र की गई चौड़ाई और ऊंचाई की जानकारी के साथ, setMeasuredDimension() तरीके को कॉल करना ज़रूरी है. अगर बदले गए onMeasure() तरीके से इस तरीके को कॉल नहीं किया जाता है, तो मेज़रमेंट के समय गड़बड़ी होती है.

onMeasure() को लागू करने का तरीका कुछ ऐसा होता है:

• बदले गए onMeasure() तरीके को चौड़ाई और ऊंचाई की खास जानकारी के साथ कॉल किया जाता है. इन्हें, आपके बनाए गए चौड़ाई और ऊंचाई के मेज़रमेंट पर लागू होने वाली पाबंदियों की ज़रूरी शर्तों के तौर पर माना जाता है. widthMeasureSpec और heightMeasureSpec पैरामीटर, दोनों डाइमेंशन को दिखाने वाले इंटिजर कोड होते हैं. इन खास जानकारी के लिए, किस तरह की पाबंदियां ज़रूरी हो सकती हैं, इसकी पूरी जानकारी रेफ़रंस के तौर पर दिए गए दस्तावेज़ में, View.onMeasure(int, int) में देखी जा सकती है. इस रेफ़रंस दस्तावेज़ में, पूरे मेज़रमेंट ऑपरेशन के बारे में भी बताया गया है.
• आपके कॉम्पोनेंट का onMeasure() तरीका, मेज़रमेंट की चौड़ाई और ऊंचाई की जानकारी कैलकुलेट करता है, कॉम्पोनेंट को रेंडर करने के लिए, यह जानकारी ज़रूरी है. इसे पास की गई खास जानकारी के दायरे में रहने की कोशिश करनी चाहिए . हालांकि, यह उससे ज़्यादा भी हो सकती है. इस मामले में, पैरंट यह तय कर सकता है कि क्या करना है. जैसे, क्लिप करना, स्क्रोल करना, गड़बड़ी दिखाना या onMeasure() से फिर से कोशिश करने के लिए कहना. ऐसा शायद अलग-अलग मेज़रमेंट की खास जानकारी के साथ किया जा सकता है.
• चौड़ाई और ऊंचाई की जानकारी कैलकुलेट करने के बाद, कैलकुलेट किए गए मेज़रमेंट के साथ setMeasuredDimension(int width, int height) तरीके को कॉल करें. ऐसा नहीं करने पर गड़बड़ी होती है.

यहां अन्य स्टैंडर्ड तरीकों की खास जानकारी दी गई है. फ़्रेमवर्क, इन्हें व्यू पर कॉल करता है:

कंपाउंड कंट्रोल

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

Android में, ऐसा करने के लिए दो अन्य व्यू उपलब्ध हैं: Spinner और AutoCompleteTextView. इसके बावजूद, कॉम्बो बॉक्स के लिए यह कॉन्सेप्ट एक अच्छा उदाहरण है.

कंपाउंड कॉम्पोनेंट बनाने के लिए, यह तरीका अपनाएं:

• जिस तरह Activity के लिए, शामिल कॉम्पोनेंट बनाने के लिए डिक्लेरेटिव (एक्सएमएल पर आधारित) तरीका इस्तेमाल किया जाता है. उसी तरह, अपने कोड से प्रोग्राम के ज़रिए उन्हें नेस्ट करें. आम तौर पर, शुरुआत किसी तरह के Layout से होती है. इसलिए, Layout को एक्सटेंड करने वाली क्लास बनाएं. कॉम्बो बॉक्स के मामले में, हॉरिज़ॉन्टल ओरिएंटेशन वाला LinearLayout इस्तेमाल किया जा सकता है. इसमें अन्य लेआउट नेस्ट किए जा सकते हैं. इसलिए, कंपाउंड कॉम्पोनेंट, ज़रूरत के हिसाब से जटिल और स्ट्रक्चर्ड हो सकता है.
• नई क्लास के कंस्ट्रक्टर में, सुपरक्लास को ज़रूरी पैरामीटर दें और उन्हें सबसे पहले सुपरक्लास कंस्ट्रक्टर में पास करें. इसके बाद, अपने नए कॉम्पोनेंट में इस्तेमाल करने के लिए अन्य व्यू सेट अप किए जा सकते हैं. यहां EditText फ़ील्ड और पॉप-अप सूची बनाई जाती है. एक्सएमएल में अपने एट्रिब्यूट और पैरामीटर जोड़े जा सकते हैं. इन्हें कंस्ट्रक्टर पुल और इस्तेमाल कर सकता है.
• ज़रूरी नहीं: उन इवेंट के लिए लिसनर बनाएं जिन्हें शामिल व्यू जनरेट कर सकते हैं. इसका एक उदाहरण, सूची आइटम क्लिक लिसनर के लिए लिसनर तरीका है. इससे, सूची में कोई आइटम चुनने पर, EditText के कॉन्टेंट को अपडेट किया जा सकता है.
• ज़रूरी नहीं: ऐक्सेसर और मॉडिफ़ायर के साथ अपनी प्रॉपर्टी बनाएं. उदाहरण के लिए, कॉम्पोनेंट में EditText की वैल्यू को शुरुआती तौर पर सेट करें और ज़रूरत पड़ने पर उसके कॉन्टेंट के लिए क्वेरी करें.
• ज़रूरी नहीं: onDraw() और onMeasure() को बदलें. `Layout` को एक्सटेंड करते समय, आम तौर पर ऐसा करना ज़रूरी नहीं होता . ऐसा इसलिए, क्योंकि लेआउट में डिफ़ॉल्ट तौर पर काम करने की सुविधा होती है. यह सुविधा, आम तौर पर ठीक काम करती है.
• ज़रूरी नहीं: अन्य on तरीकों को बदलें. जैसे, onKeyDown(). उदाहरण के लिए, किसी खास कुंजी पर टैप करने पर, कॉम्बो बॉक्स की पॉप-अप सूची से कुछ डिफ़ॉल्ट वैल्यू चुनी जा सकती हैं.

कस्टम कंट्रोल के लिए, Layout का इस्तेमाल करने के कई फ़ायदे हैं. इनमें ये शामिल हैं:

• लेआउट को डिक्लेरेटिव एक्सएमएल फ़ाइलों का इस्तेमाल करके तय किया जा सकता है. जैसे, ऐक्टिविटी स्क्रीन के लिए किया जाता है. इसके अलावा, प्रोग्राम के ज़रिए व्यू बनाए जा सकते हैं और उन्हें अपने कोड से लेआउट में नेस्ट किया जा सकता है.
• onDraw() और onMeasure() तरीकों के साथ-साथ, अन्य on तरीकों में भी सही तरीके से काम करने की सुविधा होती है. इसलिए, इन्हें बदलने की ज़रूरत नहीं होती.
• ज़रूरत के हिसाब से जटिल कंपाउंड व्यू फटाफट बनाए जा सकते हैं और उन्हें एक कॉम्पोनेंट की तरह दोबारा इस्तेमाल किया जा सकता है.

मौजूदा व्यू टाइप में बदलाव करना

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

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

अगर आपने अब तक ऐसा नहीं किया है, तो NotePad के सैंपल को Android Studio में इंपोर्ट करें या दिए गए लिंक का इस्तेमाल करके सोर्स देखें. खास तौर पर, LinedEditText फ़ाइल में NoteEditor.java की परिभाषा देखें.

इस फ़ाइल में इन बातों का ध्यान रखें:

1. परिभाषा

   क्लास को इस लाइन से तय किया जाता है:
   public static class LinedEditText extends EditText

   LinedEditText को NoteEditor ऐक्टिविटी में इनर क्लास के तौर पर तय किया गया है. हालांकि, यह पब्लिक है, ताकि इसे NoteEditor.LinedEditText क्लास के बाहर से NoteEditor के तौर पर ऐक्सेस किया जा सके.

   इसके अलावा, LinedEditText static है. इसका मतलब है कि यह तथाकथित "सिंथेटिक तरीके" जनरेट नहीं करता. इनकी मदद से, पैरंट क्लास से डेटा ऐक्सेस किया जा सकता है. इसका मतलब है कि यह एक अलग क्लास के तौर पर काम करता है, बजाय इसके कि यह NoteEditor से मज़बूती से जुड़ा हो. अगर इनर क्लास को आउटर क्लास से स्टेट ऐक्सेस करने की ज़रूरत नहीं है, तो उन्हें बनाने का यह बेहतर तरीका है. इससे जनरेट की गई क्लास का साइज़ छोटा रहता है और इसे अन्य क्लास से आसानी से इस्तेमाल किया जा सकता है.

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

2. क्लास शुरू करना

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

3. बदले गए तरीके

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

   इस सैंपल के लिए, onDraw() तरीके को बदलने से, EditText व्यू कैनवस पर नीली लाइनें पेंट की जा सकती हैं. कैनवस को बदले गए onDraw() तरीके में पास किया जाता है. तरीका खत्म होने से पहले, super.onDraw() तरीके को कॉल किया जाता है. सुपरक्लास के तरीके को लागू करना ज़रूरी है. इस मामले में, शामिल की जाने वाली लाइनें पेंट करने के बाद, आखिर में इसे लागू करें.

4. पसंद के मुताबिक बनाया गया कॉम्पोनेंट

   अब आपके पास पसंद के मुताबिक बनाया गया कॉम्पोनेंट है. हालांकि, इसका इस्तेमाल कैसे किया जा सकता है? NotePad के उदाहरण में, पसंद के मुताबिक बनाया गया कॉम्पोनेंट, डिक्लेरेटिव लेआउट से सीधे इस्तेमाल किया जाता है. इसलिए, note_editor.xml को res/layout फ़ोल्डर में देखें:

   <view xmlns:android="http://schemas.android.com/apk/res/android"
       class="com.example.android.notepad.NoteEditor$LinedEditText"
       android:id="@+id/note"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:background="@android:color/transparent"
       android:padding="5dp"
       android:scrollbars="vertical"
       android:fadingEdge="vertical"
       android:gravity="top"
       android:textSize="22sp"
       android:capitalize="sentences"
   />

   पसंद के मुताबिक बनाया गया कॉम्पोनेंट, एक्सएमएल में सामान्य व्यू के तौर पर बनाया जाता है. साथ ही, क्लास को पूरे पैकेज का इस्तेमाल करके तय किया जाता है. आपके तय की गई इनर क्लास को NoteEditor$LinedEditText नोटेशन का इस्तेमाल करके रेफ़र किया जाता है. यह Java प्रोग्रामिंग भाषा में इनर क्लास को रेफ़र करने का स्टैंडर्ड तरीका है.

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

   <com.example.android.notepad.LinedEditText
     id="@+id/note"
     ... />

   ध्यान दें कि LinedEditText क्लास अब एक अलग क्लास फ़ाइल है. जब क्लास को NoteEditor क्लास में नेस्ट किया जाता है, तब यह तरीका काम नहीं करता.

   परिभाषा में मौजूद अन्य एट्रिब्यूट और पैरामीटर, पसंद के मुताबिक बनाए गए कॉम्पोनेंट कंस्ट्रक्टर में पास किए जाते हैं. इसके बाद, इन्हें EditText कंस्ट्रक्टर में पास किया जाता है. इसलिए, ये वही पैरामीटर हैं जिनका इस्तेमाल EditText व्यू के लिए किया जाता है. अपने पैरामीटर भी जोड़े जा सकते हैं.

पसंद के मुताबिक बनाए गए कॉम्पोनेंट बनाना, आपकी ज़रूरत के हिसाब से ही मुश्किल होता है.

ज़्यादा बेहतर कॉम्पोनेंट, ज़्यादा on तरीकों को बदल सकता है और अपने हेल्पर तरीके पेश कर सकता है. इससे, इसकी प्रॉपर्टी और व्यवहार को काफ़ी हद तक पसंद के मुताबिक बनाया जा सकता है. इसकी सीमा सिर्फ़ आपकी कल्पना और कॉम्पोनेंट से आपको क्या काम कराना है, इस पर निर्भर करती है.