विजेट के हिसाब से लेआउट उपलब्ध कराएं

यह पेज विजेट के साइज़ को बेहतर बनाने और ज़्यादा सहूलियत के लिए काम करता है इसे Android 12 (एपीआई लेवल 31) में लॉन्च किया गया है. इसमें यह भी बताया गया है कि अपने विजेट के लिए साइज़ तय करें.

विजेट के साइज़ और लेआउट के लिए, बेहतर एपीआई इस्तेमाल करें

Android 12 (एपीआई लेवल 31) और उसके बाद के वर्शन में, ज़्यादा बेहतर साइज़ उपलब्ध कराया जा सकता है एट्रिब्यूट और ज़रूरत के हिसाब से लेआउट का इस्तेमाल करें. इसके बारे में ज़्यादा जानकारी के लिए, ये सेक्शन शामिल होते हैं:

1. विजेट के साइज़ से जुड़ी अन्य सीमाएं तय करें.

2. प्रतिक्रियाशील लेआउट या सटीक उपलब्ध कराकर लेआउट.

Android के पिछले वर्शन में, तो विजेट OPTION_APPWIDGET_MIN_WIDTH OPTION_APPWIDGET_MIN_HEIGHT, OPTION_APPWIDGET_MAX_WIDTH, और OPTION_APPWIDGET_MAX_HEIGHT अतिरिक्त सुविधाएं जोड़ें और फिर विजेट के साइज़ का अनुमान लगाएं, लेकिन यह लॉजिक स्थितियों के बारे में बताना. Android 12 या उसके बाद के वर्शन को टारगेट करने वाले विजेट के लिए, हमारा सुझाव है कि रिस्पॉन्सिव (स्क्रीन के हिसाब से आकार बदलने वाले) या सटीक (सटीक) में जवाब देता है लेआउट शामिल करें.

विजेट के साइज़ की अतिरिक्त सीमाएं तय करें

Android 12 में एपीआई जोड़े गए, ताकि यह पक्का किया जा सके कि आपका विजेट ये अलग-अलग स्क्रीन साइज़ के साथ, अलग-अलग डिवाइसों पर भरोसेमंद तरीके से साइज़ किए जाते हैं.

मौजूदा minWidth के अलावा, minHeight, minResizeWidth, और minResizeHeight एट्रिब्यूट की वैल्यू के तौर पर, इन नई appwidget-provider एट्रिब्यूट का इस्तेमाल करें:

• targetCellWidth और targetCellHeight: लॉन्चर ग्रिड सेल के संदर्भ में विजेट का टारगेट साइज़ तय करें. अगर आपने तय की गई है, तो minWidth या minHeight के बजाय इन एट्रिब्यूट का इस्तेमाल किया जाता है.

• maxResizeWidth और maxResizeHeight: लॉन्चर के ज़रिए उपयोगकर्ता को विजेट का ज़्यादा से ज़्यादा जिस साइज़ तक बदलने की अनुमति देता है उसे तय करें.

नीचे दिया गया एक्सएमएल, साइज़ एट्रिब्यूट को इस्तेमाल करने का तरीका बताता है.

<appwidget-provider
  ...
  android:targetCellWidth="3"
  android:targetCellHeight="2"
  android:maxResizeWidth="250dp"
  android:maxResizeHeight="110dp">
</appwidget-provider>

रिस्पॉन्सिव लेआउट देना

अगर विजेट के साइज़ के हिसाब से लेआउट को बदलना है, तो हमारा सुझाव है कि इससे लेआउट का एक छोटा सेट बन जाता है, जिसमें हर लेआउट साइज़ की रेंज के लिए मान्य होता है. अगर यह संभव नहीं है. दूसरा विकल्प सटीक विजेट के आधार पर लेआउट प्रदान करना है का आकार, जैसा कि इस पेज में बताया गया है.

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

कोड के इस उदाहरण में, लेआउट की सूची देने का तरीका बताया गया है.

override fun onUpdate(...) {
    val smallView = ...
    val tallView = ...
    val wideView = ...

    val viewMapping: Map<SizeF, RemoteViews> = mapOf(
            SizeF(150f, 100f) to smallView,
            SizeF(150f, 200f) to tallView,
            SizeF(215f, 100f) to wideView
    )
    val remoteViews = RemoteViews(viewMapping)

    appWidgetManager.updateAppWidget(id, remoteViews)
}

@Override
public void onUpdate(...) {
    RemoteViews smallView = ...;
    RemoteViews tallView = ...;
    RemoteViews wideView = ...;

    Map<SizeF, RemoteViews> viewMapping = new ArrayMap<>();
    viewMapping.put(new SizeF(150f, 100f), smallView);
    viewMapping.put(new SizeF(150f, 200f), tallView);
    viewMapping.put(new SizeF(215f, 100f), wideView);
    RemoteViews remoteViews = new RemoteViews(viewMapping);

    appWidgetManager.updateAppWidget(id, remoteViews);
}

मान लें कि विजेट में ये एट्रिब्यूट मौजूद हैं:

<appwidget-provider
    android:minResizeWidth="160dp"
    android:minResizeHeight="110dp"
    android:maxResizeWidth="250dp"
    android:maxResizeHeight="200dp">
</appwidget-provider>

ऊपर दिए गए कोड स्निपेट का यह मतलब है:

• smallView 160dp (minResizeWidth) × 110dp के साथ काम करता है (minResizeHeight) से 160dp × 199dp (अगला कटऑफ़ पॉइंट - 1dp).
• tallView 160dp × 200dp से लेकर 214dp (अगला कटऑफ़ पॉइंट - 1) × तक काम करता है 200dp.

• wideView 215dp × 110dp (minResizeHeight) से 250dp तक काम करता है (maxResizeWidth) × 200dp (maxResizeHeight).

आपके विजेट का साइज़, minResizeWidth × से ज़्यादा होना चाहिए minResizeHeight से maxResizeWidth × maxResizeHeight. उस सीमा के अंदर, लेआउट बदलने के लिए, कटऑफ़ पॉइंट तय किया जा सकता है.

सटीक लेआउट देना

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

इस समाधान को लागू करने के लिए, आपके ऐप्लिकेशन को ये चरण पूरे करने होंगे:

1. ओवरलोड AppWidgetProvider.onAppWidgetOptionsChanged(), इसे तब कहा जाता है, जब साइज़ के सेट में बदलाव होता है.

2. AppWidgetManager.getAppWidgetOptions() पर कॉल करें, जो साइज़ वाले Bundle नतीजे दिखाता है.

3. Bundle से AppWidgetManager.OPTION_APPWIDGET_SIZES कुंजी को ऐक्सेस करें.

उदाहरण के तौर पर दिया गया यह कोड, सटीक लेआउट देने का तरीका बताता है.

override fun onAppWidgetOptionsChanged(
        context: Context,
        appWidgetManager: AppWidgetManager,
        id: Int,
        newOptions: Bundle?
) {
    super.onAppWidgetOptionsChanged(context, appWidgetManager, id, newOptions)
    // Get the new sizes.
    val sizes = newOptions?.getParcelableArrayList<SizeF>(
            AppWidgetManager.OPTION_APPWIDGET_SIZES
    )
    // Check that the list of sizes is provided by the launcher.
    if (sizes.isNullOrEmpty()) {
        return
    }
    // Map the sizes to the RemoteViews that you want.
    val remoteViews = RemoteViews(sizes.associateWith(::createRemoteViews))
    appWidgetManager.updateAppWidget(id, remoteViews)
}

// Create the RemoteViews for the given size.
private fun createRemoteViews(size: SizeF): RemoteViews { }

@Override
public void onAppWidgetOptionsChanged(
    Context context, AppWidgetManager appWidgetManager, int appWidgetId, Bundle newOptions) {
    super.onAppWidgetOptionsChanged(context, appWidgetManager, appWidgetId, newOptions);
    // Get the new sizes.
    ArrayList<SizeF> sizes =
        newOptions.getParcelableArrayList(AppWidgetManager.OPTION_APPWIDGET_SIZES);
    // Check that the list of sizes is provided by the launcher.
    if (sizes == null || sizes.isEmpty()) {
      return;
    }
    // Map the sizes to the RemoteViews that you want.
    Map<SizeF, RemoteViews> viewMapping = new ArrayMap<>();
    for (SizeF size : sizes) {
        viewMapping.put(size, createRemoteViews(size));
    }
    RemoteViews remoteViews = new RemoteViews(viewMapping);
    appWidgetManager.updateAppWidget(id, remoteViews);
}

// Create the RemoteViews for the given size.
private RemoteViews createRemoteViews(SizeF size) { }

अपने विजेट का साइज़ तय करें

डिवाइसों के लिए, हर विजेट में targetCellWidth और targetCellHeight तय होने चाहिए Android 12 या इसके बाद के वर्शन पर काम कर रहा हो—या सभी के लिए minWidth और minHeight Android के वर्शन—जो कम से कम इस्तेमाल होने वाले स्टोरेज के बारे में जानकारी देते हैं डिफ़ॉल्ट रूप से. हालांकि, जब उपयोगकर्ता अपनी होम स्क्रीन पर कोई विजेट जोड़ते हैं, तो जगह, आपके तय की गई कम से कम चौड़ाई और ऊंचाई से ज़्यादा जगह लेती है.

Android की होम स्क्रीन पर, उपयोगकर्ताओं को उपलब्ध स्पेस का एक ग्रिड मिलता है, जिस पर वे स्थान विजेट और आइकन. यह ग्रिड, डिवाइस के हिसाब से अलग-अलग हो सकता है; उदाहरण के लिए, कई हैंडसेट 5x4 ग्रिड ऑफ़र करते हैं और टैबलेट बड़ी ग्रिड ऑफ़र कर सकते हैं. जब आपका विजेट जोड़ा जाता है, तो यह सेल की सबसे कम संख्या तक फैल जाता है, हॉरिज़ॉन्टल और वर्टिकल तौर पर, शर्तों को पूरा करने के लिए ज़रूरी होता है. targetCellWidth और targetCellHeight इन डिवाइसों पर चल रहे हैं Android 12 या उसके बाद के वर्शन या minWidth और minHeight की पाबंदियां चालू हैं Android 11 (एपीआई लेवल 30) या इससे पहले के वर्शन वाले डिवाइसों पर.

सेल की चौड़ाई और ऊंचाई और अपने-आप मिलने वाले मार्जिन का साइज़, दोनों लागू किए गए में उपलब्ध विजेट, सभी डिवाइसों पर अलग-अलग हो सकते हैं. मोटे तौर पर अनुमान लगाने के लिए, नीचे दी गई टेबल का इस्तेमाल करें आपके विजेट के कम से कम डाइमेंशन, सामान्य 5x4 ग्रिड हैंडसेट में होते हैं. व्यस्त ग्रिड सेल की संख्या:

अपनी तय की गई वैल्यू के बारे में बताने के लिए, पोर्ट्रेट मोड वाले सेल के साइज़ का इस्तेमाल करें minWidth, minResizeWidth, और maxResizeWidth एट्रिब्यूट. इसी तरह, आपकी दी गई वैल्यू के बारे में बताने के लिए, लैंडस्केप मोड वाले सेल साइज़ का इस्तेमाल करें minHeight, minResizeHeight, और maxResizeHeight एट्रिब्यूट के लिए.

इसकी वजह यह है कि पोर्ट्रेट मोड में सेल की चौड़ाई आम तौर पर कम होती है की तुलना में लैंडस्केप मोड के मुकाबले काम करती है—और इसी तरह सेल की ऊंचाई आम तौर पर लैंडस्केप मोड में पोर्ट्रेट मोड से छोटा होता है.

उदाहरण के लिए, अगर आपको अपने विजेट की चौड़ाई को कम करके एक सेल पर सेट करना है, तो Google Pixel 4, आपको अपने minResizeWidth को ज़्यादा से ज़्यादा 56dp पर सेट करना होगा यह पक्का करने के लिए कि minResizeWidth एट्रिब्यूट की वैल्यू कम हो 57dp से अलग हो सकता है—क्योंकि पोर्ट्रेट में सेल की चौड़ाई कम से कम 57dp है. इसी तरह, अगर आप चाहते हैं कि विजेट की ऊंचाई का साइज़, उसी डिवाइस के लिए, आपको अपने minResizeHeight को ज़्यादा से ज़्यादा 50dp पर सेट करना होगा, ताकि यह पक्का किया जा सके कि minResizeHeight विशेषता के लिए मान इससे छोटा है 51dp—क्योंकि लैंडस्केप मोड में एक सेल कम से कम 51dp ज़्यादा होता है.

हर विजेट का साइज़ इन चीज़ों के बीच की साइज़ रेंज में बदला जा सकता है minResizeWidth/minResizeHeight और maxResizeWidth/maxResizeHeight एट्रिब्यूट का इस्तेमाल किया जाता है, जिसका मतलब है कि यह उनके बीच के किसी भी साइज़ की रेंज के हिसाब से होना चाहिए.

उदाहरण के लिए, प्लेसमेंट पर विजेट का डिफ़ॉल्ट साइज़ सेट करने के लिए, ये एट्रिब्यूट सेट करें:

<appwidget-provider
    android:targetCellWidth="3"
    android:targetCellHeight="2"
    android:minWidth="180dp"
    android:minHeight="110dp">
</appwidget-provider>

इसका मतलब है कि विजेट का डिफ़ॉल्ट साइज़ 3x2 सेल है, जैसा कि targetCellWidth और targetCellHeight एट्रिब्यूट—या 180×110dp, जैसा चल रहे डिवाइस के लिए minWidth और minHeight के ज़रिए तय किया गया Android 11 या इससे पहले का वर्शन हो. बाद वाले मामले में, सेल का आकार अलग-अलग हो सकते हैं.

साथ ही, अपने विजेट के लिए सही साइज़ रेंज सेट करने के लिए, ये चीज़ें सेट की जा सकती हैं: विशेषताएं:

<appwidget-provider
    android:minResizeWidth="180dp"
    android:minResizeHeight="110dp"
    android:maxResizeWidth="530dp"
    android:maxResizeHeight="450dp">
</appwidget-provider>

जैसा कि पहले वाले एट्रिब्यूट में बताया गया है, बैज की चौड़ाई 180dp से 530dp तक का साइज़ बदला जा सकता है. इसकी ऊंचाई 110dp से 450dp तक बदली जा सकती है. इसके बाद, विजेट का साइज़ 3x2 से लेकर 5x2 सेल तक बदला जा सकता है. ऐसा तब किया जा सकता है, जब ये शर्तें मौजूद हैं:

• डिवाइस में 5x4 ग्रिड होता है.
• सेल की संख्या और डीपी (डेंसिटी इंडिपेंडेंट पिक्सल) में उपलब्ध साइज़ के बीच की मैपिंग टेबल में कम से कम डाइमेंशन के बारे में ज़्यादा जानें.
• विजेट उस साइज़ की सीमा के हिसाब से छोटा या बड़ा हो जाता है.

val smallView = RemoteViews(context.packageName, R.layout.widget_weather_forecast_small)
val mediumView = RemoteViews(context.packageName, R.layout.widget_weather_forecast_medium)
val largeView = RemoteViews(context.packageName, R.layout.widget_weather_forecast_large)

val viewMapping: Map<SizeF, RemoteViews> = mapOf(
        SizeF(180f, 110f) to smallView,
        SizeF(270f, 110f) to mediumView,
        SizeF(270f, 280f) to largeView
)

appWidgetManager.updateAppWidget(appWidgetId, RemoteViews(viewMapping))

RemoteViews smallView = 
    new RemoteViews(context.getPackageName(), R.layout.widget_weather_forecast_small);
RemoteViews mediumView = 
    new RemoteViews(context.getPackageName(), R.layout.widget_weather_forecast_medium);
RemoteViews largeView = 
    new RemoteViews(context.getPackageName(), R.layout.widget_weather_forecast_large);

Map<SizeF, RemoteViews> viewMapping = new ArrayMap<>();
viewMapping.put(new SizeF(180f, 110f), smallView);
viewMapping.put(new SizeF(270f, 110f), mediumView);
viewMapping.put(new SizeF(270f, 280f), largeView);
RemoteViews remoteViews = new RemoteViews(viewMapping);

appWidgetManager.updateAppWidget(id, remoteViews);

मान लें कि विजेट उन रिस्पॉन्सिव लेआउट का इस्तेमाल करता है जिनके बारे में पहले बताया गया है कोड स्निपेट. इसका मतलब है कि लेआउट R.layout.widget_weather_forecast_small का इस्तेमाल 180dp (minResizeWidth) x से किया गया है 110dp (minResizeHeight) से 269x279dp (अगला कटऑफ़ पॉइंट - 1). इसी तरह, R.layout.widget_weather_forecast_medium का इस्तेमाल 270x110dp से 270x279dp तक किया गया है, और R.layout.widget_weather_forecast_large का इस्तेमाल 270x280dp से लेकर 530dp (maxResizeWidth) x 450dp (maxResizeHeight).

जैसे-जैसे उपयोगकर्ता विजेट का साइज़ बदलता है, विजेट का लुक, हर साइज़ के हिसाब से बदलता रहता है सेल भी देखें, जैसा कि नीचे दिए गए उदाहरणों में दिखाया गया है.