एक आसान विजेट बनाएं

ऐप्लिकेशन विजेट, ऐप्लिकेशन के छोटे व्यू होते हैं. इन्हें होम स्क्रीन जैसे अन्य ऐप्लिकेशन में जोड़ा जा सकता है. साथ ही, इनमें समय-समय पर अपडेट मिलते रहते हैं. इन व्यू को यूज़र इंटरफ़ेस में विजेट कहा जाता है. साथ ही, ऐप्लिकेशन विजेट की सेवा देने वाली कंपनी (या विजेट की सेवा देने वाली कंपनी) की मदद से, इनमें से किसी एक को पब्लिश किया जा सकता है. अन्य विजेट को होस्ट करने वाले ऐप्लिकेशन कॉम्पोनेंट को ऐप्लिकेशन विजेट होस्ट (या विजेट होस्ट) कहा जाता है. पहली इमेज में, संगीत विजेट का सैंपल दिखाया गया है:

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

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

विजेट के कॉम्पोनेंट

विजेट बनाने के लिए, आपको इन बुनियादी कॉम्पोनेंट की ज़रूरत होगी:

AppWidgetProviderInfo ऑब्जेक्ट

इससे किसी विजेट के मेटाडेटा के बारे में पता चलता है. जैसे, विजेट का लेआउट, अपडेट की फ़्रीक्वेंसी, और AppWidgetProvider क्लास. AppWidgetProviderInfo को एक्सएमएल में तय किया गया है, जैसा कि इस दस्तावेज़ में बताया गया है.

AppWidgetProvider क्लास

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

व्यू का लेआउट

विजेट के लिए शुरुआती लेआउट तय करता है. इस दस्तावेज़ में बताए गए तरीके के मुताबिक, लेआउट को एक्सएमएल में तय किया गया है.

दूसरे चित्र में दिखाया गया है कि ये कॉम्पोनेंट, ऐप्लिकेशन विजेट को प्रोसेस करने के पूरे फ़्लो में कैसे फ़िट होते हैं.

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

• Android 12 (एपीआई लेवल 31) से, डिफ़ॉल्ट कॉन्फ़िगरेशन दिया जा सकता है. साथ ही, उपयोगकर्ताओं को बाद में विजेट को फिर से कॉन्फ़िगर करने की अनुमति दी जा सकती है. ज़्यादा जानकारी के लिए, विजेट के डिफ़ॉल्ट कॉन्फ़िगरेशन का इस्तेमाल करना और उपयोगकर्ताओं को प्लेस किए गए विजेट को फिर से कॉन्फ़िगर करने की सुविधा देना देखें.
• Android 11 (एपीआई लेवल 30) या इससे पहले के वर्शन में, जब भी उपयोगकर्ता अपनी होम स्क्रीन पर विजेट जोड़ता है, तब यह गतिविधि शुरू होती है.

हम इन सुधारों का भी सुझाव देते हैं: विजेट के लेआउट में बदलाव, अन्य सुधार, ऐडवांस विजेट, कलेक्शन विजेट, और विजेट होस्ट बनाना.

AppWidgetProviderInfo एक्सएमएल का एलान करना

AppWidgetProviderInfo ऑब्जेक्ट, विजेट की ज़रूरी विशेषताओं के बारे में बताता है. किसी एक <appwidget-provider> एलिमेंट का इस्तेमाल करके, एक्सएमएल रिसॉर्स फ़ाइल में AppWidgetProviderInfo ऑब्जेक्ट तय करें और उसे प्रोजेक्ट के res/xml/ फ़ोल्डर में सेव करें.

यह नीचे दिए गए उदाहरण में दिखाया गया है:

<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
    android:minWidth="40dp"
    android:minHeight="40dp"
    android:targetCellWidth="1"
    android:targetCellHeight="1"
    android:maxResizeWidth="250dp"
    android:maxResizeHeight="120dp"
    android:updatePeriodMillis="86400000"
    android:description="@string/example_appwidget_description"
    android:previewLayout="@layout/example_appwidget_preview"
    android:initialLayout="@layout/example_loading_appwidget"
    android:configure="com.example.android.ExampleAppWidgetConfigurationActivity"
    android:resizeMode="horizontal|vertical"
    android:widgetCategory="home_screen"
    android:widgetFeatures="reconfigurable|configuration_optional">
</appwidget-provider>

विजेट के साइज़ से जुड़े एट्रिब्यूट

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

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

नीचे दी गई टेबल में, विजेट के साइज़ से जुड़े <appwidget-provider> एट्रिब्यूट के बारे में बताया गया है:

उदाहरण

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

• ग्रिड सेल की चौड़ाई 30 dp और ऊंचाई 50 dp है.
• इस एट्रिब्यूट के बारे में यहां बताया गया है:

<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
    android:minWidth="80dp"
    android:minHeight="80dp"
    android:targetCellWidth="2"
    android:targetCellHeight="2"
    android:minResizeWidth="40dp"
    android:minResizeHeight="40dp"
    android:maxResizeWidth="120dp"
    android:maxResizeHeight="120dp"
    android:resizeMode="horizontal|vertical" />

Android 12 से:

विजेट के डिफ़ॉल्ट साइज़ के तौर पर, targetCellWidth और targetCellHeight एट्रिब्यूट का इस्तेमाल करें.

विजेट का साइज़ डिफ़ॉल्ट रूप से 2x2 होता है. विजेट का साइज़ 2x1 या 4x3 तक किया जा सकता है.

Android 11 और उससे पहले के वर्शन के लिए:

विजेट के डिफ़ॉल्ट साइज़ का हिसाब लगाने के लिए, minWidth और minHeight एट्रिब्यूट का इस्तेमाल करें.

डिफ़ॉल्ट चौड़ाई = Math.ceil(80 / 30) = 3

डिफ़ॉल्ट ऊंचाई = Math.ceil(80 / 50) = 2

विजेट का साइज़ डिफ़ॉल्ट रूप से 3x2 होता है. विजेट का साइज़ 2x1 तक छोटा या फ़ुल स्क्रीन तक बड़ा किया जा सकता है.

विजेट के अन्य एट्रिब्यूट

नीचे दी गई टेबल में, विजेट के साइज़ के अलावा अन्य एट्रिब्यूट के बारे में बताया गया है.<appwidget-provider>

विजेट ब्रॉडकास्ट मैनेज करने के लिए, AppWidgetProvider क्लास का इस्तेमाल करना

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

मेनिफ़ेस्ट में विजेट की जानकारी देना

सबसे पहले, अपने ऐप्लिकेशन की AndroidManifest.xml फ़ाइल में AppWidgetProvider क्लास का एलान करें, जैसा कि इस उदाहरण में दिखाया गया है:

<receiver android:name="ExampleAppWidgetProvider"
                 android:exported="false">
    <intent-filter>
        <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
    </intent-filter>
    <meta-data android:name="android.appwidget.provider"
               android:resource="@xml/example_appwidget_info" />
</receiver>

<receiver> एलिमेंट के लिए android:name एट्रिब्यूट ज़रूरी है. इससे, विजेट के लिए इस्तेमाल किए गए AppWidgetProvider के बारे में पता चलता है. कॉम्पोनेंट को तब तक एक्सपोर्ट नहीं किया जाना चाहिए, जब तक कि आपके AppWidgetProvider पर किसी अलग प्रोसेस को ब्रॉडकास्ट करने की ज़रूरत न हो. आम तौर पर, ऐसा नहीं होता.

<intent-filter> एलिमेंट में, android:name एट्रिब्यूट वाला <action> एलिमेंट शामिल होना चाहिए. इस एट्रिब्यूट से पता चलता है कि AppWidgetProvider, ACTION_APPWIDGET_UPDATE का ब्रॉडकास्ट स्वीकार करता है. आपको सिर्फ़ इस ब्रॉडकास्ट के बारे में साफ़ तौर पर बताना होगा. AppWidgetManager, ज़रूरत पड़ने पर AppWidgetProvider पर अन्य सभी विजेट ब्रॉडकास्ट अपने-आप भेजता है.

<meta-data> एलिमेंट, AppWidgetProviderInfo संसाधन के बारे में बताता है और इसके लिए इन एट्रिब्यूट की ज़रूरत होती है:

• android:name: मेटाडेटा का नाम बताता है. डेटा को AppWidgetProviderInfo डिस्क्रिप्टर के तौर पर पहचानने के लिए, android.appwidget.provider का इस्तेमाल करें.
• android:resource: AppWidgetProviderInfo संसाधन की जगह की जानकारी देता है.

AppWidgetProvider क्लास लागू करना

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

onUpdate()

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

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

सबसे ज़रूरी कॉलबैक onUpdate() है. ज़्यादा जानकारी के लिए, इस पेज पर onUpdate() क्लास की मदद से इवेंट मैनेज करना देखें.

onAppWidgetOptionsChanged()

यह तब ट्रिगर होता है, जब विजेट को पहली बार प्लेस किया जाता है और जब भी विजेट का साइज़ बदला जाता है. विजेट के साइज़ की सीमाओं के आधार पर कॉन्टेंट दिखाने या छिपाने के लिए, इस कॉलबैक का इस्तेमाल करें. getAppWidgetOptions() को कॉल करके, साइज़ की सीमाएं पाएं. साथ ही, Android 12 से, विजेट के इंस्टेंस के संभावित साइज़ की सूची पाएं. इससे Bundle मिलता है, जिसमें ये शामिल होते हैं:

• OPTION_APPWIDGET_MIN_WIDTH: इसमें विजेट इंस्टेंस की चौड़ाई की निचली सीमा, डीपी इकाइयों में होती है.
• OPTION_APPWIDGET_MIN_HEIGHT: इसमें विजेट इंस्टेंस की ऊंचाई का निचला बाउंड, डीपी यूनिट में होता है.
• OPTION_APPWIDGET_MAX_WIDTH: इसमें विजेट इंस्टेंस की चौड़ाई की ऊपरी सीमा, डीपी इकाइयों में होती है.
• OPTION_APPWIDGET_MAX_HEIGHT: इसमें विजेट इंस्टेंस की ऊंचाई की ऊपरी सीमा, डीपी यूनिट में होती है.
• OPTION_APPWIDGET_SIZES: इसमें dp इकाइयों में, संभावित साइज़ (List<SizeF>) की सूची होती है. ये ऐसे साइज़ होते हैं जिनमें विजेट का इंस्टेंस हो सकता है. यह सुविधा Android 12 में लॉन्च की गई थी.

onDeleted(Context, int[])

विजेट होस्ट से विजेट मिटाने पर, यह इवेंट ट्रिगर होता है.

onEnabled(Context)

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

onDisabled(Context)

यह तब ट्रिगर होता है, जब विजेट होस्ट से आपके विजेट का आखिरी इंस्टेंस मिटाया जाता है. यहां onEnabled(Context) में किए गए किसी भी काम को मिटाया जा सकता है. जैसे, कुछ समय के लिए सेव किया गया डेटाबेस मिटाना.

onReceive(Context, Intent)

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

आपको AndroidManifest में <receiver> एलिमेंट का इस्तेमाल करके, अपनी AppWidgetProvider क्लास को ब्रॉडकास्ट रिसीवर के तौर पर लागू करने का एलान करना होगा. ज़्यादा जानकारी के लिए, इस पेज पर मेनिफ़ेस्ट में विजेट का एलान करना देखें.

onUpdate() क्लास की मदद से इवेंट मैनेज करना

AppWidgetProvider कॉलबैक में सबसे अहम onUpdate() होता है, क्योंकि जब भी किसी होस्ट में विजेट जोड़ा जाता है, तब इसे कॉल किया जाता है. ऐसा तब तक होता है, जब तक configuration_optional फ़्लैग के बिना कॉन्फ़िगरेशन गतिविधि का इस्तेमाल नहीं किया जाता. अगर आपका विजेट, उपयोगकर्ता के किसी इंटरैक्शन इवेंट को स्वीकार करता है, तो इस कॉलबैक में इवेंट हैंडलर रजिस्टर करें. अगर आपका विजेट, अस्थायी फ़ाइलें या डेटाबेस नहीं बनाता है या ऐसा कोई काम नहीं करता है जिसके लिए क्लीन-अप की ज़रूरत होती है, तो हो सकता है कि आपको सिर्फ़ onUpdate() कॉलबैक का तरीका तय करना पड़े.

उदाहरण के लिए, अगर आपको ऐसा विजेट चाहिए जिसमें टैप करने पर कोई गतिविधि शुरू हो, तो AppWidgetProvider को लागू करने के लिए यह तरीका अपनाएं:

class ExampleAppWidgetProvider : AppWidgetProvider() {

    override fun onUpdate(
            context: Context,
            appWidgetManager: AppWidgetManager,
            appWidgetIds: IntArray
    ) {
        // Perform this loop procedure for each widget that belongs to this
        // provider.
        appWidgetIds.forEach { appWidgetId ->
            // Create an Intent to launch ExampleActivity.
            val pendingIntent: PendingIntent = PendingIntent.getActivity(
                    /* context = */ context,
                    /* requestCode = */  0,
                    /* intent = */ Intent(context, ExampleActivity::class.java),
                    /* flags = */ PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
            )

            // Get the layout for the widget and attach an onClick listener to
            // the button.
            val views: RemoteViews = RemoteViews(
                    context.packageName,
                    R.layout.appwidget_provider_layout
            ).apply {
                setOnClickPendingIntent(R.id.button, pendingIntent)
            }

            // Tell the AppWidgetManager to perform an update on the current
            // widget.
            appWidgetManager.updateAppWidget(appWidgetId, views)
        }
    }
}

public class ExampleAppWidgetProvider extends AppWidgetProvider {

    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
        // Perform this loop procedure for each widget that belongs to this
        // provider.
        for (int i=0; i < appWidgetIds.length; i++) {
            int appWidgetId = appWidgetIds[i];
            // Create an Intent to launch ExampleActivity
            Intent intent = new Intent(context, ExampleActivity.class);
            PendingIntent pendingIntent = PendingIntent.getActivity(
                /* context = */ context,
                /* requestCode = */ 0,
                /* intent = */ intent,
                /* flags = */ PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
            );

            // Get the layout for the widget and attach an onClick listener to
            // the button.
            RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.example_appwidget_layout);
            views.setOnClickPendingIntent(R.id.button, pendingIntent);

            // Tell the AppWidgetManager to perform an update on the current app
            // widget.
            appWidgetManager.updateAppWidget(appWidgetId, views);
        }
    }
}

यह AppWidgetProvider सिर्फ़ onUpdate() तरीके को तय करता है. इसका इस्तेमाल, PendingIntent बनाने के लिए किया जाता है, जो Activity को लॉन्च करता है और setOnClickPendingIntent(int, PendingIntent) का इस्तेमाल करके, इसे विजेट के बटन से जोड़ता है. इसमें एक लूप शामिल होता है, जो appWidgetIds में मौजूद हर एंट्री को दोहराता है. यह आईडी का एक कलेक्शन होता है, जो इस सेवा देने वाली कंपनी के बनाए गए हर विजेट की पहचान करता है. अगर उपयोगकर्ता विजेट का एक से ज़्यादा इंस्टेंस बनाता है, तो वे सभी एक साथ अपडेट हो जाते हैं. हालांकि, विजेट के सभी इंस्टेंस के लिए सिर्फ़ एक updatePeriodMillis शेड्यूल मैनेज किया जाता है. उदाहरण के लिए, अगर अपडेट के शेड्यूल को हर दो घंटे पर सेट किया गया है और विजेट का दूसरा इंस्टेंस, पहले इंस्टेंस के एक घंटे बाद जोड़ा जाता है, तो दोनों को पहले इंस्टेंस के लिए तय की गई अवधि के हिसाब से अपडेट किया जाता है. साथ ही, अपडेट की दूसरी अवधि को अनदेखा कर दिया जाता है. ये दोनों हर घंटे नहीं, बल्कि हर दो घंटे में अपडेट होते हैं.

ज़्यादा जानकारी के लिए, ExampleAppWidgetProvider.java के सैंपल क्लास को देखें.

विजेट ब्रॉडकास्ट इंटेंट पाना

AppWidgetProvider एक सुविधा क्लास है. अगर आपको विजेट के ब्रॉडकास्ट सीधे तौर पर चाहिए, तो अपना BroadcastReceiver लागू करें या onReceive(Context,Intent) कॉलबैक को बदलें. आपको इन इंटेंट पर ध्यान देने की ज़रूरत है:

• ACTION_APPWIDGET_UPDATE
• ACTION_APPWIDGET_DELETED
• ACTION_APPWIDGET_ENABLED
• ACTION_APPWIDGET_DISABLED
• ACTION_APPWIDGET_OPTIONS_CHANGED

विजेट का लेआउट बनाना

आपको अपने विजेट के लिए, एक्सएमएल में शुरुआती लेआउट तय करना होगा और उसे प्रोजेक्ट की res/layout/ डायरेक्ट्री में सेव करना होगा. ज़्यादा जानकारी के लिए, डिज़ाइन के लिए दिशा-निर्देश देखें.

अगर आपको लेआउट के बारे में पता है, तो विजेट का लेआउट बनाना आसान है. हालांकि, ध्यान रखें कि विजेट के लेआउट RemoteViews पर आधारित होते हैं. यह हर तरह के लेआउट या व्यू विजेट के साथ काम नहीं करता. RemoteViews के साथ काम करने वाले कस्टम व्यू या व्यू के सबक्लास का इस्तेमाल नहीं किया जा सकता.

RemoteViews में ViewStub का भी इस्तेमाल किया जा सकता है. यह एक ऐसा View है जो न तो दिखता है और न ही इसका कोई साइज़ होता है. इसका इस्तेमाल, रनटाइम के दौरान लेआउट के संसाधनों को धीरे-धीरे बढ़ाने के लिए किया जा सकता है.

स्टेटफ़ुल व्यवहार के लिए सहायता

Android 12 में, इन मौजूदा कॉम्पोनेंट का इस्तेमाल करके, स्टेटफ़ुल व्यवहार के लिए सहायता जोड़ी गई है:

• CheckBox

• Switch

• RadioButton

विजेट अब भी स्टेटलेस है. आपके ऐप्लिकेशन को स्थिति सेव करनी होगी और स्थिति में बदलाव होने के इवेंट के लिए रजिस्टर करना होगा.

नीचे दिए गए कोड के उदाहरण में, इन कॉम्पोनेंट को लागू करने का तरीका बताया गया है.

// Check the view.
remoteView.setCompoundButtonChecked(R.id.my_checkbox, true)

// Check a radio group.
remoteView.setRadioGroupChecked(R.id.my_radio_group, R.id.radio_button_2)

// Listen for check changes. The intent has an extra with the key
// EXTRA_CHECKED that specifies the current checked state of the view.
remoteView.setOnCheckedChangeResponse(
        R.id.my_checkbox,
        RemoteViews.RemoteResponse.fromPendingIntent(onCheckedChangePendingIntent)
)

// Check the view.
remoteView.setCompoundButtonChecked(R.id.my_checkbox, true);

// Check a radio group.
remoteView.setRadioGroupChecked(R.id.my_radio_group, R.id.radio_button_2);

// Listen for check changes. The intent has an extra with the key
// EXTRA_CHECKED that specifies the current checked state of the view.
remoteView.setOnCheckedChangeResponse(
    R.id.my_checkbox,
    RemoteViews.RemoteResponse.fromPendingIntent(onCheckedChangePendingIntent));

दो लेआउट उपलब्ध कराएं: पहला, res/layout-v31 में Android 12 या उसके बाद के वर्शन पर काम करने वाले डिवाइसों को टारगेट करने वाला और दूसरा, डिफ़ॉल्ट res/layout फ़ोल्डर में Android 11 या उससे पहले के वर्शन पर काम करने वाले डिवाइसों को टारगेट करने वाला.

गोल कोने लागू करना

Android 12 में, विजेट के गोल कोनों की त्रिज्या सेट करने के लिए, ये सिस्टम पैरामीटर जोड़े गए हैं:

• system_app_widget_background_radius: विजेट के बैकग्राउंड के कोने का दायरा, जो कभी भी 28 dp से ज़्यादा नहीं होता.

• system_app_widget_inner_radius: विजेट में मौजूद किसी भी व्यू के कोने का दायरा. यह बैकग्राउंड त्रिज्या से 8 dp कम है, ताकि 8 dp पैडिंग का इस्तेमाल करते समय, आइटम को सही तरीके से अलाइन किया जा सके.

यहां दिए गए उदाहरण में एक विजेट दिखाया गया है, जिसमें विजेट के कोने के लिए system_app_widget_background_radius और विजेट में मौजूद व्यू के लिए system_app_widget_inner_radius का इस्तेमाल किया गया है.

1 विजेट का कोना.

2 विजेट में मौजूद व्यू का कोना.

राउंड किए गए कोनों के लिए ज़रूरी बातें

• तीसरे पक्ष के लॉन्चर और डिवाइस बनाने वाली कंपनियां, system_app_widget_background_radius पैरामीटर को 28 dp से छोटा कर सकती हैं. system_app_widget_inner_radius पैरामीटर की वैल्यू, system_app_widget_background_radius की वैल्यू से हमेशा 8 dp कम होती है.
• अगर आपका विजेट @android:id/background का इस्तेमाल नहीं करता है या ऐसा बैकग्राउंड तय नहीं करता है जो आउटलाइन के आधार पर अपने कॉन्टेंट को क्लिप करता है, तो लॉन्चर अपने-आप बैकग्राउंड की पहचान करता है और 16 डीपी तक के गोल कोनों वाले रेक्टैंगल का इस्तेमाल करके विजेट को क्लिप करता है. ऐसा तब होता है, जब android:clipToOutline को true पर सेट किया गया हो. पक्का करें कि आपका विजेट, Android 12 के साथ काम करता हो लेख पढ़ें.

Android के पिछले वर्शन के साथ विजेट के काम करने के लिए, हमारा सुझाव है कि आप कस्टम एट्रिब्यूट तय करें. साथ ही, Android 12 के लिए उन्हें बदलने के लिए, कस्टम थीम का इस्तेमाल करें. इस बारे में, यहां दी गई एक्सएमएल फ़ाइलों के सैंपल में बताया गया है:

<resources>
  <attr name="backgroundRadius" format="dimension" />
</resources>

<resources>
  <style name="MyWidgetTheme">
    <item name="backgroundRadius">@dimen/my_background_radius_dimen</item>
  </style>
</resources>

<resources>
  <style name="MyWidgetTheme" parent="@android:style/Theme.DeviceDefault.DayNight">
    <item name="backgroundRadius">@android:dimen/system_app_widget_background_radius</item>
  </style>
</resources>

<shape xmlns:android="http://schemas.android.com/apk/res/android"
  android:shape="rectangle">
  <corners android:radius="?attr/backgroundRadius" />
  ...
</shape>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  ...
  android:background="@drawable/my_widget_background" />