Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

ड्रॉएबल के बारे में खास जानकारी

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

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

क्लास कंस्ट्रक्टर का इस्तेमाल करने के अलावा, Drawable को परिभाषित और इंस्टैंशिएट करने के दो तरीके हैं:

आपके प्रोजेक्ट में सेव की गई इमेज रिसॉर्स (बिटमैप फ़ाइल) को बड़ा करता है.
ड्रॉएबल प्रॉपर्टी तय करने वाले एक्सएमएल रिसॉर्स को इनफ़्लेट करें.

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

संसाधन इमेज से ड्रॉएबल बनाना

अपने प्रोजेक्ट के संसाधनों से इमेज फ़ाइल का रेफ़रंस देकर, अपने ऐप्लिकेशन में ग्राफ़िक जोड़े जा सकते हैं. PNG (बेहतर), JPG (स्वीकार किया जा सकता है), और GIF (इस्तेमाल न करने का सुझाव दिया जाता है) फ़ाइल टाइप का इस्तेमाल किया जा सकता है. ऐप्लिकेशन के आइकॉन, लोगो, और अन्य ग्राफ़िक के लिए यह तकनीक सबसे सही है. जैसे, गेम में इस्तेमाल किए गए ग्राफ़िक.

इमेज रिसॉर्स का इस्तेमाल करने के लिए, अपनी फ़ाइल को अपने प्रोजेक्ट की res/drawable/ डायरेक्ट्री में जोड़ें. अपने प्रोजेक्ट में इमेज रिसॉर्स को शामिल करने के बाद, उसे अपने कोड या एक्सएमएल लेआउट में रेफ़रंस किया जा सकता है. दोनों ही मामलों में, इसे रिसॉर्स आईडी का इस्तेमाल करके रेफ़र किया जाता है. यह फ़ाइल टाइप एक्सटेंशन के बिना फ़ाइल का नाम होता है. उदाहरण के लिए, my_image.png को my_image के तौर पर देखें.

ध्यान दें: res/drawable/ डायरेक्ट्री में रखी गई इमेज ऐसेट, बिल्ड प्रोसेस के दौरान aapt टूल की मदद से, बिना क्वालिटी में बदलाव किए इमेज कंप्रेस करने की सुविधा के साथ अपने-आप ऑप्टिमाइज़ हो सकती हैं. उदाहरण के लिए, किसी ऐसे ट्रू-कलर पीएनजी को 8-बिट पीएनजी में बदला जा सकता है जिसमें 256 से ज़्यादा रंगों की ज़रूरत नहीं होती. इसमें कलर पैलेट भी होता है. इससे एक ऐसी इमेज तैयार होती है जिसकी क्वालिटी पहले जैसी ही होती है, लेकिन यह कम मेमोरी इस्तेमाल करती है. इस वजह से, इस डायरेक्ट्री में मौजूद इमेज बाइनरी, बिल्ड के समय बदल सकती हैं. अगर आपको किसी इमेज को बिटमैप में बदलने के लिए, उसे बिटस्ट्रीम के तौर पर पढ़ना है, तो अपनी इमेज को res/raw/ फ़ोल्डर में रखें. यहां aapt टूल, इमेज में बदलाव नहीं करता है.

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

Kotlin

private lateinit var constraintLayout: ConstraintLayout

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // Instantiate an ImageView and define its properties
    val i = ImageView(this).apply {
        setImageResource(R.drawable.my_image)
        contentDescription = resources.getString(R.string.my_image_desc)

        // set the ImageView bounds to match the Drawable's dimensions
        adjustViewBounds = true
        layoutParams = ViewGroup.LayoutParams(
                ViewGroup.LayoutParams.WRAP_CONTENT,
                ViewGroup.LayoutParams.WRAP_CONTENT)
    }

    // Create a ConstraintLayout in which to add the ImageView
    constraintLayout = ConstraintLayout(this).apply {

        // Add the ImageView to the layout.
        addView(i)
    }

    // Set the layout as the content view.
    setContentView(constraintLayout)
}

Java

ConstraintLayout constraintLayout;

protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);

  // Create a ConstraintLayout in which to add the ImageView
  constraintLayout = new ConstraintLayout(this);

  // Instantiate an ImageView and define its properties
  ImageView i = new ImageView(this);
  i.setImageResource(R.drawable.my_image);
  i.setContentDescription(getResources().getString(R.string.my_image_desc));

  // set the ImageView bounds to match the Drawable's dimensions
  i.setAdjustViewBounds(true);
  i.setLayoutParams(new ViewGroup.LayoutParams(
          ViewGroup.LayoutParams.WRAP_CONTENT,
          ViewGroup.LayoutParams.WRAP_CONTENT));

  // Add the ImageView to the layout and set the layout as the content view.
  constraintLayout.addView(i);
  setContentView(constraintLayout);
}

कुछ अन्य मामलों में, आपको अपनी इमेज रिसॉर्स को Drawable ऑब्जेक्ट के तौर पर मैनेज करना पड़ सकता है. इसका उदाहरण यहां दिया गया है:

Kotlin

val myImage: Drawable = ResourcesCompat.getDrawable(context.resources, R.drawable.my_image, null)

Java

Resources res = context.getResources();
Drawable myImage = ResourcesCompat.getDrawable(res, R.drawable.my_image, null);

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

नीचे दिए गए एक्सएमएल स्निपेट में, एक्सएमएल लेआउट में ImageView में ड्रॉएबल रिसॉर्स जोड़ने का तरीका बताया गया है:

<ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/my_image"
        android:contentDescription="@string/my_image_desc" />

प्रोजेक्ट के संसाधनों का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, संसाधन और ऐसेट लेख पढ़ें.

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

एक्सएमएल संसाधनों से ड्रॉएबल बनाना

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

एक्सएमएल में Drawable तय करने के बाद, फ़ाइल को अपने प्रोजेक्ट की res/drawable/ डायरेक्ट्री में सेव करें. यहां दिए गए उदाहरण में, TransitionDrawable रिसॉर्स को तय करने वाला एक्सएमएल दिखाया गया है. यह Drawable से इनहेरिट करता है:

<!-- res/drawable/expand_collapse.xml -->
<transition xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@drawable/image_expand"/>
    <item android:drawable="@drawable/image_collapse"/>
</transition>

इसके बाद, Resources#getDrawable() को कॉल करके ऑब्जेक्ट को वापस पाएं और इंस्टैंटिएट करें. साथ ही, अपनी एक्सएमएल फ़ाइल का संसाधन आईडी पास करें. Drawable तरीके के साथ काम करने वाली किसी भी Drawable सबक्लास को एक्सएमएल में तय किया जा सकता है. साथ ही, आपका ऐप्लिकेशन उसे इंस्टैंशिएट कर सकता है.inflate()

अहम जानकारी: Drawable के सबक्लास को बढ़ाने वाली कस्टम क्लास को getConstantState() मेथड को बदलना होगा. नीचे कस्टम ड्रॉएबल में मुख्य जानकारी देखें.

एक्सएमएल इन्फ़्लेशन की सुविधा देने वाली हर ड्रॉएबल क्लास, खास एक्सएमएल एट्रिब्यूट का इस्तेमाल करती है. ये एट्रिब्यूट, ऑब्जेक्ट की प्रॉपर्टी तय करने में मदद करते हैं. नीचे दिए गए कोड में, TransitionDrawable को इंस्टैंशिएट किया गया है और इसे ImageView ऑब्जेक्ट के कॉन्टेंट के तौर पर सेट किया गया है:

Kotlin

val transition= ResourcesCompat.getDrawable(
        context.resources,
        R.drawable.expand_collapse,
        null
) as TransitionDrawable

val image: ImageView = findViewById(R.id.toggle_image)
image.setImageDrawable(transition)

// Description of the initial state that the drawable represents.
image.contentDescription = resources.getString(R.string.collapsed)

// Then you can call the TransitionDrawable object's methods.
transition.startTransition(1000)

// After the transition is complete, change the image's content description
// to reflect the new state.

Java

Resources res = context.getResources();
TransitionDrawable transition =
    (TransitionDrawable) ResourcesCompat.getDrawable(res, R.drawable.expand_collapse, null);

ImageView image = (ImageView) findViewById(R.id.toggle_image);
image.setImageDrawable(transition);

// Description of the initial state that the drawable represents.
image.setContentDescription(getResources().getString(R.string.collapsed));

// Then you can call the TransitionDrawable object's methods.
transition.startTransition(1000);

// After the transition is complete, change the image's content description
// to reflect the new state.

इस्तेमाल किए जा सकने वाले एक्सएमएल एट्रिब्यूट के बारे में ज़्यादा जानने के लिए, ऊपर दी गई क्लास देखें.

शेप ड्रॉएबल

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

ShapeDrawable, Drawable की सबक्लास है. इस वजह से, जहां Drawable की ज़रूरत होती है वहां ShapeDrawable का इस्तेमाल किया जा सकता है. उदाहरण के लिए, किसी व्यू का बैकग्राउंड सेट करने के लिए, ShapeDrawable ऑब्जेक्ट का इस्तेमाल किया जा सकता है. इसके लिए, इसे व्यू के setBackgroundDrawable() तरीके में पास करें. अपने आकार को कस्टम व्यू के तौर पर भी बनाया जा सकता है. इसके बाद, इसे अपने ऐप्लिकेशन के लेआउट में जोड़ा जा सकता है.

ShapeDrawable में अपना draw() तरीका होता है. इसलिए, View की एक सबक्लास बनाई जा सकती है, जो onDraw() इवेंट के दौरान ShapeDrawable ऑब्जेक्ट को ड्रॉ करती है. इसका उदाहरण यहां दिया गया है:

Kotlin

class CustomDrawableView(context: Context) : View(context) {
    private val drawable: ShapeDrawable = run {
        val x = 10
        val y = 10
        val width = 300
        val height = 50
        contentDescription = context.resources.getString(R.string.my_view_desc)

        ShapeDrawable(OvalShape()).apply {
            // If the color isn't set, the shape uses black as the default.
            paint.color = 0xff74AC23.toInt()
            // If the bounds aren't set, the shape can't be drawn.
            setBounds(x, y, x + width, y + height)
        }
    }

    override fun onDraw(canvas: Canvas) {
        drawable.draw(canvas)
    }
}

Java

public class CustomDrawableView extends View {
  private ShapeDrawable drawable;

  public CustomDrawableView(Context context) {
    super(context);

    int x = 10;
    int y = 10;
    int width = 300;
    int height = 50;
    setContentDescription(context.getResources().getString(
            R.string.my_view_desc));

    drawable = new ShapeDrawable(new OvalShape());
    // If the color isn't set, the shape uses black as the default.
    drawable.getPaint().setColor(0xff74AC23);
    // If the bounds aren't set, the shape can't be drawn.
    drawable.setBounds(x, y, x + width, y + height);
  }

  protected void onDraw(Canvas canvas) {
    drawable.draw(canvas);
  }
}

ऊपर दिए गए कोड सैंपल में मौजूद CustomDrawableView क्लास का इस्तेमाल, किसी अन्य कस्टम व्यू की तरह किया जा सकता है. उदाहरण के लिए, इसे प्रोग्राम के हिसाब से अपने ऐप्लिकेशन की किसी गतिविधि में जोड़ा जा सकता है. इसे इस उदाहरण में दिखाया गया है:

Kotlin

private lateinit var customDrawableView: CustomDrawableView

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    customDrawableView = CustomDrawableView(this)

    setContentView(customDrawableView)
}

Java

CustomDrawableView customDrawableView;

protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  customDrawableView = new CustomDrawableView(this);

  setContentView(customDrawableView);
}

अगर आपको एक्सएमएल लेआउट में कस्टम व्यू का इस्तेमाल करना है, तो CustomDrawableView क्लास को View(Context, AttributeSet) कंस्ट्रक्टर को ओवरराइड करना होगा. इस कंस्ट्रक्टर को तब कॉल किया जाता है, जब क्लास को एक्सएमएल से बढ़ाया जाता है. यहां दिए गए उदाहरण में, एक्सएमएल लेआउट में CustomDrawableView का एलान करने का तरीका बताया गया है:

<com.example.shapedrawable.CustomDrawableView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        />

ShapeDrawable क्लास, android.graphics.drawable पैकेज में मौजूद कई अन्य ड्रॉएबल टाइप की तरह ही होती है. इसकी मदद से, सार्वजनिक तरीकों का इस्तेमाल करके ऑब्जेक्ट की अलग-अलग प्रॉपर्टी तय की जा सकती हैं. कुछ उदाहरण प्रॉपर्टी, जिन्हें आपको शायद अडजस्ट करना पड़े. इनमें ऐल्फ़ा पारदर्शिता, कलर फ़िल्टर, डिथर, ओपैसिटी, और रंग शामिल हैं.

एक्सएमएल संसाधनों का इस्तेमाल करके, प्रिमिटिव ड्रॉएबल शेप भी तय किए जा सकते हैं. ज़्यादा जानकारी के लिए, ड्रॉएबल रिसॉर्स टाइप में शेप ड्रॉएबल देखें.

NinePatch ड्रॉएबल

NinePatchDrawable ग्राफ़िक, स्ट्रेच की जा सकने वाली बिटमैप इमेज होती है. इसका इस्तेमाल व्यू के बैकग्राउंड के तौर पर किया जा सकता है. Android, व्यू के कॉन्टेंट के हिसाब से ग्राफ़िक का साइज़ अपने-आप बदल देता है. NinePatch इमेज का इस्तेमाल करने का एक उदाहरण, Android के स्टैंडर्ड बटन के लिए इस्तेमाल किया गया बैकग्राउंड है. बटन को अलग-अलग लंबाई वाली स्ट्रिंग के हिसाब से स्ट्रेच होना चाहिए. नाइनपैच ग्राफ़िक, स्टैंडर्ड PNG इमेज होती है. इसमें एक पिक्सल का अतिरिक्त बॉर्डर शामिल होता है. इसे आपके प्रोजेक्ट की res/drawable/ डायरेक्ट्री में 9.png एक्सटेंशन के साथ सेव किया जाना चाहिए.

बॉर्डर का इस्तेमाल करके, इमेज के उन हिस्सों को तय करें जिन्हें स्ट्रेच किया जा सकता है और जिन्हें स्ट्रेच नहीं किया जा सकता. बढ़ाए जा सकने वाले सेक्शन को दिखाने के लिए, बॉर्डर के बाईं और ऊपरी हिस्से में एक या उससे ज़्यादा 1-पिक्सल चौड़ी काली लाइनें बनाएं. बॉर्डर के अन्य पिक्सल पूरी तरह से पारदर्शी या सफ़ेद होने चाहिए. आपके पास जितने चाहें उतने स्ट्रेचेबल सेक्शन हो सकते हैं. स्ट्रेच किए जा सकने वाले सेक्शन का साइज़ एक जैसा रहता है. इसलिए, सबसे बड़ा सेक्शन हमेशा सबसे बड़ा ही रहता है.

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

लाइनों के बीच के अंतर को समझने के लिए, बाईं और सबसे ऊपर वाली लाइनें यह तय करती हैं कि इमेज के किन पिक्सल को दोहराने की अनुमति है, ताकि इमेज को स्ट्रेच किया जा सके. नीचे और दाईं ओर की लाइनें, इमेज में उस जगह को दिखाती हैं जहां व्यू का कॉन्टेंट दिख सकता है.

पहली इमेज में, बटन को तय करने के लिए इस्तेमाल किए गए NinePatch ग्राफ़िक का उदाहरण दिखाया गया है:

स्ट्रेच किए जा सकने वाले हिस्से और पैडिंग बॉक्स की इमेज

पहली इमेज: बटन को तय करने वाले NinePatch ग्राफ़िक का उदाहरण

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

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

यहां दिए गए सैंपल लेआउट एक्सएमएल में, कुछ बटन में NinePatch ग्राफ़िक जोड़ने का तरीका बताया गया है. NinePatch इमेज को res/drawable/my_button_background.9.png में सेव किया जाता है.

<Button android:id="@+id/tiny"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerInParent="true"
        android:text="Tiny"
        android:textSize="8sp"
        android:background="@drawable/my_button_background"/>

<Button android:id="@+id/big"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentBottom="true"
        android:layout_centerInParent="true"
        android:text="Biiiiiiig text!"
        android:textSize="30sp"
        android:background="@drawable/my_button_background"/>

ध्यान दें कि layout_width और layout_height एट्रिब्यूट को wrap_content पर सेट किया गया है, ताकि बटन टेक्स्ट के चारों ओर सही तरीके से फ़िट हो सके.

दूसरी इमेज में, ऊपर दिखाई गई एक्सएमएल और NinePatch इमेज से रेंडर किए गए दो बटन दिखाए गए हैं. ध्यान दें कि टेक्स्ट के हिसाब से बटन की चौड़ाई और ऊंचाई कैसे बदलती है. साथ ही, बैकग्राउंड इमेज को टेक्स्ट के हिसाब से कैसे स्ट्रेच किया जाता है.

दूसरी इमेज: XML रिसॉर्स और NinePatch ग्राफ़िक का इस्तेमाल करके रेंडर किए गए बटन

पसंद के मुताबिक बनाए गए ड्रॉएबल

अगर आपको कुछ कस्टम ड्रॉइंग बनानी हैं, तो Drawable क्लास (या इसकी किसी भी सबक्लास) को बढ़ाकर ऐसा किया जा सकता है.

लागू करने का सबसे ज़रूरी तरीका draw(Canvas) है, क्योंकि यह Canvas ऑब्जेक्ट उपलब्ध कराता है. इस ऑब्जेक्ट का इस्तेमाल करके, आपको ड्राइंग के निर्देश देने होते हैं.

नीचे दिए गए कोड में, Drawable की एक सामान्य सबक्लास दिखाई गई है, जो एक सर्कल बनाती है:

Kotlin

class MyDrawable : Drawable() {
    private val redPaint: Paint = Paint().apply { setARGB(255, 255, 0, 0) }

    override fun draw(canvas: Canvas) {
        // Get the drawable's bounds
        val width: Int = bounds.width()
        val height: Int = bounds.height()
        val radius: Float = Math.min(width, height).toFloat() / 2f

        // Draw a red circle in the center
        canvas.drawCircle((width / 2).toFloat(), (height / 2).toFloat(), radius, redPaint)
    }

    override fun setAlpha(alpha: Int) {
        // This method is required
    }

    override fun setColorFilter(colorFilter: ColorFilter?) {
        // This method is required
    }

    override fun getOpacity(): Int =
        // Must be PixelFormat.UNKNOWN, TRANSLUCENT, TRANSPARENT, or OPAQUE
        PixelFormat.OPAQUE
}

Java

public class MyDrawable extends Drawable {
    private final Paint redPaint;

    public MyDrawable() {
        // Set up color and text size
        redPaint = new Paint();
        redPaint.setARGB(255, 255, 0, 0);
    }

    @Override
    public void draw(Canvas canvas) {
        // Get the drawable's bounds
        int width = getBounds().width();
        int height = getBounds().height();
        float radius = Math.min(width, height) / 2;

        // Draw a red circle in the center
        canvas.drawCircle(width/2, height/2, radius, redPaint);
    }

    @Override
    public void setAlpha(int alpha) {
        // This method is required
    }

    @Override
    public void setColorFilter(ColorFilter colorFilter) {
        // This method is required
    }

    @Override
    public int getOpacity() {
        // Must be PixelFormat.UNKNOWN, TRANSLUCENT, TRANSPARENT, or OPAQUE
        return PixelFormat.OPAQUE;
    }
}

इसके बाद, अपने ड्रॉएबल को जहां चाहें वहां जोड़ा जा सकता है. जैसे, यहां दिखाए गए तरीके से ImageView में:

Kotlin

val myDrawing = MyDrawable()
val image: ImageView = findViewById(R.id.imageView)
image.setImageDrawable(myDrawing)
image.contentDescription = resources.getString(R.string.my_image_desc)

Java

MyDrawable mydrawing = new MyDrawable();
ImageView image = findViewById(R.id.imageView);
image.setImageDrawable(mydrawing);
image.setContentDescription(getResources().getString(R.string.my_image_desc));

Android 7.0 (एपीआई लेवल 24) और इसके बाद के वर्शन पर, एक्सएमएल का इस्तेमाल करके कस्टम ड्रॉएबल के इंस्टेंस को इन तरीकों से भी तय किया जा सकता है:

एक्सएमएल एलिमेंट के नाम के तौर पर, पूरी तरह क्वालिफ़ाइड क्लास के नाम का इस्तेमाल करना. इस तरीके के लिए, कस्टम ड्रॉएबल क्लास, टॉप-लेवल की सार्वजनिक क्लास होनी चाहिए:
```
<com.myapp.MyDrawable xmlns:android="http://schemas.android.com/apk/res/android"
    android:color="#ffff0000" />
```
एक्सएमएल टैग के नाम के तौर पर drawable का इस्तेमाल करना और क्लास एट्रिब्यूट से पूरी तरह क्वालिफ़ाइड क्लास का नाम तय करना. इस तरीके का इस्तेमाल, सार्वजनिक टॉप-लेवल क्लास और सार्वजनिक स्टैटिक इनर क्लास, दोनों के लिए किया जा सकता है:
```
<drawable xmlns:android="http://schemas.android.com/apk/res/android"
    class="com.myapp.MyTopLevelClass$MyDrawable"
    android:color="#ffff0000" />
```

अहम जानकारी: Drawable (जैसे कि ColorDrawable) की सबक्लास को बढ़ाने वाली कस्टम क्लास को getConstantState() तरीके को बदलना होगा और शून्य (या सही Drawable.ConstantState) वैल्यू दिखानी होगी. इससे यह पक्का किया जा सकेगा कि कस्टम क्लास के सभी इन्फ्लेटेड इंस्टेंस सही टाइप के हों. कस्टम क्लास को बढ़ाने के लिए, Resources#getDrawable() को पहली बार कॉल करने पर हमेशा एक ऐसा इंस्टेंस बनता है जो कस्टम टाइप का होता है. उदाहरण के लिए, MyColorDrawable. हालांकि, इसके बाद किए गए कॉल ऐसे इंस्टेंस बनाते हैं जो पैरंट टाइप के होते हैं. उदाहरण के लिए, ColorDrawable. ऐसा तब होता है, जब getConstantState() को बदला नहीं जाता. Drawable को सीधे तौर पर सबक्लास करने वाली कस्टम क्लास को getConstantState() को ओवरराइड करने की ज़रूरत नहीं होती.

ड्रॉएबल में टिंट जोड़ना

Android 5.0 (एपीआई लेवल 21) और इसके बाद के वर्शन में, ऐल्फ़ा मास्क के तौर पर तय किए गए बिटमैप और नाइन-पैच को रंग दिया जा सकता है. इन्हें कलर रिसॉर्स या थीम एट्रिब्यूट की मदद से रंग दिया जा सकता है. ये एट्रिब्यूट, कलर रिसॉर्स (उदाहरण के लिए, ?android:attr/colorPrimary) में बदल जाते हैं. आम तौर पर, इन ऐसेट को सिर्फ़ एक बार बनाया जाता है और आपकी थीम से मेल खाने के लिए, इन्हें अपने-आप रंग दिया जाता है.

setTint() तरीके का इस्तेमाल करके, BitmapDrawable, NinePatchDrawable या VectorDrawable ऑब्जेक्ट पर टिंट लागू किया जा सकता है. android:tint और android:tintMode एट्रिब्यूट की मदद से, अपने लेआउट में रंगत का रंग और मोड भी सेट किया जा सकता है.

किसी इमेज से मुख्य रंग निकालना

Android Support Library में Palette क्लास शामिल है. इसकी मदद से, किसी इमेज से मुख्य रंग निकाले जा सकते हैं. अपने ड्रॉएबल को Bitmap के तौर पर लोड किया जा सकता है. इसके बाद, इसके रंगों को ऐक्सेस करने के लिए, इसे Palette को पास किया जा सकता है. ज़्यादा जानकारी के लिए, Palette API की मदद से रंग चुनना लेख पढ़ें.