व्यू क्लास बनाना

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

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

  • यह Android के स्टैंडर्ड के मुताबिक हो.
  • इसमें स्टाइल वाले कस्टम एट्रिब्यूट शामिल हों, जो Android के एक्सएमएल लेआउट के साथ काम करते हों.
  • यह सुलभता से जुड़े इवेंट भेजता हो.
  • यह Android के कई प्लैटफ़ॉर्म के साथ काम करता हो.

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

ज़्यादा जानकारी के लिए, कस्टम व्यू कॉम्पोनेंट लेख पढ़ें.

किसी व्यू की सबक्लास बनाना

Android फ़्रेमवर्क में तय की गई सभी व्यू क्लास, View को एक्सटेंड करती हैं. आपका कस्टम व्यू भी सीधे तौर पर View को एक्सटेंड कर सकता है. इसके अलावा, मौजूदा व्यू सबक्लास में से किसी एक को एक्सटेंड करके, समय बचाया जा सकता है. जैसे, Button.

Android Studio को अपने व्यू के साथ इंटरैक्ट करने की अनुमति देने के लिए, कम से कम आपको एक ऐसा कंस्ट्रक्टर उपलब्ध कराना होगा जो पैरामीटर के तौर पर Context और AttributeSet ऑब्जेक्ट लेता हो. इस कंस्ट्रक्टर की मदद से, लेआउट एडिटर आपके व्यू का इंस्टेंस बना और उसमें बदलाव कर सकता है.

Kotlin

class PieChart(context: Context, attrs: AttributeSet) : View(context, attrs)

Java

class PieChart extends View {
    public PieChart(Context context, AttributeSet attrs) {
        super(context, attrs);
    }
}

कस्टम एट्रिब्यूट तय करना

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

  • <declare-styleable> रिसॉर्स एलिमेंट में, अपने व्यू के लिए कस्टम एट्रिब्यूट तय करें.
  • अपने एक्सएमएल लेआउट में एट्रिब्यूट के लिए वैल्यू तय करें.
  • रनटाइम पर एट्रिब्यूट की वैल्यू वापस पाएं.
  • अपने व्यू पर, वापस पाई गई एट्रिब्यूट की वैल्यू लागू करें.

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

कस्टम एट्रिब्यूट तय करने के लिए, अपने प्रोजेक्ट में <declare-styleable> रिसॉर्स जोड़ें. आम तौर पर, इन रिसॉर्स को res/values/attrs.xml फ़ाइल में रखा जाता है. यहां एक attrs.xml फ़ाइल का उदाहरण दिया गया है: 

<resources>
   <declare-styleable name="PieChart">
       <attr name="showText" format="boolean" />
       <attr name="labelPosition" format="enum">
           <enum name="left" value="0"/>
           <enum name="right" value="1"/>
       </attr>
   </declare-styleable>
</resources>

इस कोड में, दो कस्टम एट्रिब्यूट, showText और labelPosition तय किए गए हैं. ये दोनों, PieChart नाम की स्टाइल वाली इकाई से जुड़े हैं. आम तौर पर, स्टाइल वाली इकाई का नाम वही होता है जो कस्टम व्यू तय करने वाली क्लास का नाम होता है. हालांकि, इस चलन को फ़ॉलो करना ज़रूरी नहीं है. फिर भी, कई लोकप्रिय कोड एडिटर, स्टेटमेंट पूरा करने की सुविधा देने के लिए, नाम रखने के इस चलन पर निर्भर करते हैं.

कस्टम एट्रिब्यूट तय करने के बाद, उन्हें लेआउट एक्सएमएल फ़ाइलों में, पहले से मौजूद एट्रिब्यूट की तरह ही इस्तेमाल किया जा सकता है. फ़र्क़ सिर्फ़ इतना है कि आपके कस्टम एट्रिब्यूट, किसी दूसरे नेमस्पेस से जुड़े होते हैं. ये http://schemas.android.com/apk/res/android नेमस्पेस से नहीं, बल्कि http://schemas.android.com/apk/res/[your package name] नेमस्पेस से जुड़े होते हैं. उदाहरण के लिए, यहां बताया गया है कि PieChart के लिए तय किए गए एट्रिब्यूट का इस्तेमाल कैसे करें: 

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:custom="http://schemas.android.com/apk/res-auto">
 <com.example.customviews.charting.PieChart
     custom:showText="true"
     custom:labelPosition="left" />
</LinearLayout>

नेमस्पेस के लंबे यूआरआई को बार-बार दोहराने से बचने के लिए, सैंपल में एक xmlns डायरेक्टिव का इस्तेमाल किया गया है. यह डायरेक्टिव, नेमस्पेस http://schemas.android.com/apk/res/com.example.customviews को एलियास custom असाइन करता है. अपने नेमस्पेस के लिए, अपनी पसंद का कोई भी एलियास चुना जा सकता है.

उस एक्सएमएल टैग के नाम पर ध्यान दें जो लेआउट में कस्टम व्यू जोड़ता है. यह कस्टम व्यू क्लास का पूरी तरह क्वालिफ़ाइड नाम है. अगर आपकी व्यू क्लास, इनर क्लास है, तो उसे व्यू की आउटर क्लास के नाम से और क्वालिफ़ाई करें. उदाहरण के लिए, the PieChart क्लास में PieView नाम की एक इनर क्लास है. इस क्लास के कस्टम एट्रिब्यूट का इस्तेमाल करने के लिए, com.example.customviews.charting.PieChart$PieView टैग का इस्तेमाल करें.

कस्टम एट्रिब्यूट लागू करना

जब किसी व्यू को एक्सएमएल लेआउट से बनाया जाता है, तो एक्सएमएल टैग में मौजूद सभी एट्रिब्यूट, रिसॉर्स बंडल से पढ़े जाते हैं. इसके बाद, इन्हें व्यू के कंस्ट्रक्टर में AttributeSet के तौर पर पास किया जाता है. `AttributeSet` से सीधे वैल्यू पढ़ी जा सकती हैं. हालांकि, ऐसा करने के कुछ नुकसान हैं:

  • एट्रिब्यूट की वैल्यू में मौजूद रिसॉर्स रेफ़रंस को हल नहीं किया जाता.
  • स्टाइल लागू नहीं किए जाते.

इसके बजाय, AttributeSet को obtainStyledAttributes() में पास करें. यह तरीका, वैल्यू का TypedArray कलेक्शन वापस पास करता है. इन वैल्यू को पहले ही डीरेफ़रंस किया जा चुका होता है और इन पर स्टाइल लागू किए जा चुके होते हैं.

Android रिसॉर्स कंपाइलर, obtainStyledAttributes() को कॉल करना आसान बनाने के लिए, आपके लिए कई काम करता है. हर <declare-styleable> रिसॉर्स के लिए, res/ डायरेक्ट्री में, जनरेट किया गया R.java एट्रिब्यूट आईडी का कलेक्शन और कॉन्स्टैंट का एक सेट, दोनों तय करता है. कॉन्स्टैंट का सेट, कलेक्शन में मौजूद हर एट्रिब्यूट के इंडेक्स को तय करता है. `TypedArray` से एट्रिब्यूट पढ़ने के लिए, पहले से तय किए गए कॉन्स्टैंट का इस्तेमाल करें.TypedArray `PieChart` क्लास, अपने एट्रिब्यूट को इस तरह पढ़ती है:

Kotlin

init {
    context.theme.obtainStyledAttributes(
            attrs,
            R.styleable.PieChart,
            0, 0).apply {

        try {
            mShowText = getBoolean(R.styleable.PieChart_showText, false)
            textPos = getInteger(R.styleable.PieChart_labelPosition, 0)
        } finally {
            recycle()
        }
    }
}

Java

public PieChart(Context context, AttributeSet attrs) {
   super(context, attrs);
   TypedArray a = context.getTheme().obtainStyledAttributes(
        attrs,
        R.styleable.PieChart,
        0, 0);

   try {
       mShowText = a.getBoolean(R.styleable.PieChart_showText, false);
       textPos = a.getInteger(R.styleable.PieChart_labelPosition, 0);
   } finally {
       a.recycle();
   }
}

ध्यान दें कि TypedArray ऑब्जेक्ट शेयर किया गया रिसॉर्स होता है. इसलिए, इस्तेमाल के बाद इसे रीसाइकल करना ज़रूरी है.

प्रॉपर्टी और इवेंट जोड़ना

एट्रिब्यूट, व्यू के व्यवहार और दिखने के तरीके को कंट्रोल करने का एक असरदार तरीका है. हालांकि, इन्हें सिर्फ़ तब पढ़ा जा सकता है, जब व्यू को शुरू किया जाता है. डाइनैमिक व्यवहार देने के लिए, हर कस्टम एट्रिब्यूट के लिए, प्रॉपर्टी गेटर और सेटर पेयर को ऐक्सेस करने की अनुमति दें. यहां दिए गए स्निपेट में, PieChart की प्रॉपर्टी को ऐक्सेस करने की अनुमति देने का तरीका बताया गया है:showText

Kotlin

fun isShowText(): Boolean {
    return mShowText
}

fun setShowText(showText: Boolean) {
    mShowText = showText
    invalidate()
    requestLayout()
}

Java

public boolean isShowText() {
   return mShowText;
}

public void setShowText(boolean showText) {
   mShowText = showText;
   invalidate();
   requestLayout();
}

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

कस्टम व्यू में, अहम इवेंट की जानकारी देने के लिए, इवेंट लिसनर की सुविधा भी होनी चाहिए. उदाहरण के लिए, PieChart एक कस्टम इवेंट दिखाता है. इससे लिसनर को यह सूचना मिलती है कि उपयोगकर्ता ने पाई चार्ट को घुमाकर, पाई के नए स्लाइस पर फ़ोकस किया है.OnCurrentItemChanged

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

सुलभता के लिए डिज़ाइन

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

  • अपने इनपुट फ़ील्ड को android:contentDescription एट्रिब्यूट का इस्तेमाल करके लेबल करें.
  • ज़रूरत पड़ने पर, sendAccessibilityEvent() को कॉल करके, सुलभता से जुड़े इवेंट भेजें.
  • डी-पैड या ट्रैकबॉल जैसे वैकल्पिक कंट्रोलर के लिए सहायता उपलब्ध कराएं.

सुलभ व्यू बनाने के बारे में ज़्यादा जानकारी के लिए, ऐप्लिकेशन को ज़्यादा सुलभ बनाना लेख पढ़ें.